File manager

package.json

@@ -8,23 +8,7 @@
   },
   "type": "module",
   "scripts": {
-    "cli:args": "node src/cli/args.js --some-arg value1 --other 1337 --arg2 42",
-    "cli:env": "npx cross-env SOME=any RSS_foo=bar RSS_bar=baz node src/cli/env.js",
-    "cp": "node src/cp/cp.js",
-    "fs:copy": "node src/fs/copy.js",
-    "fs:create": "node src/fs/create.js",
-    "fs:delete": "node src/fs/delete.js",
-    "fs:list": "node src/fs/list.js",
-    "fs:read": "node src/fs/read.js",
-    "fs:rename": "node src/fs/rename.js",
-    "hash": "node src/hash/calcHash.js",
-    "modules": "node src/modules/esm.mjs",
-    "streams:read": "node src/streams/read.js",
-    "streams:transform": "node src/streams/transform.js",
-    "streams:write": "node src/streams/write.js",
-    "wt": "node src/wt/main.js",
-    "zip:compress": "node src/zip/compress.js",
-    "zip:decompress": "node src/zip/decompress.js"
+    "start": "node src/index.mjs"
   },
   "repository": {
     "type": "git",

src/cli/args.mjs

@@ -0,0 +1,10 @@
+export const getValueByCLIArgs = (findName = '--') => { 
+    const fullArg = process.argv
+        .slice(2)
+        .find(a => a.startsWith(`${findName}=`));
+
+    if (!fullArg) return undefined;
+
+    const idx = fullArg.indexOf('=');
+    return idx >= 0 ? fullArg.slice(idx + 1) : undefined;
+};

src/cli/path.mjs

@@ -0,0 +1,69 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+import { DATA_TYPES } from '../constants/index.mjs'
+
+const normalizeSeparators = (inputPath = '') => {
+  if (!inputPath) return inputPath;
+
+  if (process.platform === 'win32') {
+    return inputPath.replace(/\//g, path.win32.sep);
+  }
+
+  return inputPath.replace(/\\/g, path.posix.sep);
+};
+
+
+export const isPathExist = async (pathForCheck) => {
+  try {
+    const normalized = normalizeSeparators(pathForCheck);
+    await fs.stat(normalized);
+  } catch(err) {
+    return false;
+  }
+  return true;
+}
+
+export const getLastNameFromPath = (inputPath) => {
+  const normalized = normalizeSeparators(inputPath);
+  const arrOfArgs = normalized.split(path.sep);
+  return arrOfArgs[arrOfArgs.length - 1];
+};
+
+
+export const getNewPathFromInput = async (inputPath, pathToCurrentDir, isNewPath) => {
+  if (!inputPath) throw new Error('Path is required');
+
+  const normalizedTarget = normalizeSeparators(inputPath);
+  const normalizedBase = normalizeSeparators(pathToCurrentDir);
+
+  const newPath = path.isAbsolute(normalizedTarget)
+    ? path.resolve(normalizedTarget)
+    : path.resolve(normalizedBase, normalizedTarget);
+
+  if (isNewPath) {
+    if (await isPathExist(newPath)) throw new Error(`${newPath} already exists.`);
+  } else {
+    await fs.stat(newPath);
+  }
+
+  return newPath;
+};
+
+
+export const getUpPath = (currentPath) => {
+  const normalized = normalizeSeparators(currentPath);
+  const { root } = path.parse(normalized);
+  if (normalized === root) return root;
+  return path.dirname(normalized);
+};
+
+export const getElTypeFromPath = async (pathToEl) => {
+  const normalized = normalizeSeparators(pathToEl);
+  const stat = await fs.lstat(normalized);
+  const isDir = stat.isDirectory();
+  if (isDir) return DATA_TYPES.directory;
+  const isFile = stat.isFile();
+  if (isFile) return DATA_TYPES.file;
+  return undefined;
+};

src/constants/index.mjs

@@ -0,0 +1,37 @@
+export const FLAG_CONSTANTS = {
+    USERNAME_FLAG: '--username',
+};
+
+export const COMMAND_CONSTANTS = {
+    exit: '.exit',
+    up: 'up',
+    cd: 'cd',
+    ls: 'ls',
+    cat: 'cat',
+    add: 'add',
+    mkdir: 'mkdir',
+    rn: 'rn',
+    cp: 'cp',
+    mv: 'mv',
+    rm: 'rm',
+    os: 'os',
+    hash: 'hash',
+    compress: 'compress',
+    decompress: 'decompress',
+};
+
+export const OPERATING_SYSTEM_CONSTANTS = {
+    EOL: '--EOL',
+    cpus: '--cpus',
+    homedir: '--homedir',
+    username: '--username',
+    architecture: '--architecture',
+};
+
+export const OPERATION_FAILED_ERROR_TEXT_MESSAGE = 'Operation failed';
+export const FS_OPERATION_FAILED_ERROR_TEXT_MESSAGE = 'FS operation failed';
+
+export const DATA_TYPES = {
+    file: 'file',
+    directory: 'directory',
+}

src/fs/create.mjs

@@ -0,0 +1,31 @@
+import fs from 'node:fs/promises';
+
+import { FS_OPERATION_FAILED_ERROR_TEXT_MESSAGE } from '../constants/index.mjs';
+const createFile = async (pathToFile) => {
+    try {
+        await fs.access(pathToFile, fs.constants.F_OK);
+    }
+    catch (err) {
+        await fs.writeFile(pathToFile, '');
+        process.stdout.write('File created.\n');
+        return; 
+    }
+    throw new Error(FS_OPERATION_FAILED_ERROR_TEXT_MESSAGE); 
+};
+
+const createDirectory = async (pathToDirectory) => {
+    try {
+        await fs.access(pathToDirectory, fs.constants.F_OK);
+    }
+    catch (err) {
+        await fs.mkdir(pathToDirectory, { recursive: true });
+        process.stdout.write('Directory created.\n');
+        return; 
+    }
+    throw new Error(FS_OPERATION_FAILED_ERROR_TEXT_MESSAGE); 
+}
+
+export {
+    createFile,
+    createDirectory
+}

src/fs/delete.mjs

@@ -0,0 +1,8 @@
+import { unlink } from 'node:fs/promises';
+
+const deleteFile = async (pathToDeleteFile, skipMessage) => {
+    await unlink(pathToDeleteFile);
+    if (!skipMessage) process.stdout.write(`${pathToDeleteFile} file deleted.\n`)
+};
+
+export default deleteFile;

src/fs/list.mjs

@@ -0,0 +1,54 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { getElTypeFromPath } from '../cli/path.mjs';
+import { FS_OPERATION_FAILED_ERROR_TEXT_MESSAGE, DATA_TYPES } from '../constants/index.mjs';
+
+export const getList = async (pathToDir) => {
+    try {
+        const files = await fs.readdir(pathToDir, {encoding: 'utf-8'});
+        return files;
+    }
+    catch(err) {
+        throw new Error(FS_OPERATION_FAILED_ERROR_TEXT_MESSAGE);
+    }
+};
+
+export const printTable = async (pathToCurrentDir) => {
+  const list = await getList(pathToCurrentDir);
+
+  if (list.length === 0) {
+    console.log('Directory is empty.');
+    return;
+  }
+
+  class Item {
+        constructor(name, type) {
+            this.Name = name
+            this.Type = type
+        }
+    }
+
+  const pairsList = await Promise.all(
+    list.map(async (el) => {
+      const pathToEl = pathToCurrentDir + path.sep + el;
+      const typeOfFile = await getElTypeFromPath(pathToEl);
+
+      return { name: el, type: typeOfFile };
+    })
+  );
+
+  const dirFirstSortedList = pairsList
+    .filter((pair) => pair.type)
+    .sort((a, b) => {
+      if (a.type === b.type) return a.name.localeCompare(b.name);
+      return a.type === DATA_TYPES.directory ? -1 : 1;
+    });
+
+  const table = dirFirstSortedList.reduce((acc, cur, idx) => {
+    acc[idx] = new Item(cur.name, cur.type);
+    return acc;
+  }, {});
+
+  console.table(table);
+};

src/fs/rename.mjs

@@ -0,0 +1,17 @@
+import fs from 'node:fs/promises';
+
+import { isPathExist ,getElTypeFromPath } from '../cli/path.mjs';
+import { DATA_TYPES } from '../constants/index.mjs';
+
+const rename = async (pathToRename, newPath) => {
+    if (await isPathExist(pathToRename)
+        && !await isPathExist(newPath)
+        && await getElTypeFromPath(pathToRename) === DATA_TYPES.file) {
+            await fs.rename(pathToRename, newPath);
+            process.stdout.write('Renamed.\n');
+    } else {
+        throw new Error ('Can not rename.');
+    }
+};
+
+export default rename;

src/hash/calcHash.mjs

@@ -0,0 +1,24 @@
+import { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import { pipeline } from 'node:stream/promises';
+import { Writable } from 'node:stream';
+
+const calculateHash = async (pathToFile) => {
+    const hash = createHash('sha256');
+
+    const output = new Writable({
+        write(chunk, encoding, callback) {
+            hash.update(chunk);
+            callback();
+        }
+    });
+
+    await pipeline(
+        createReadStream(pathToFile),
+        output
+    );
+
+    process.stdout.write(hash.digest('hex') + '\n');
+};
+
+export default calculateHash;