implemented commander library to my cat, ls and wc file

Author: MansoorM11

.DS_Store

@@ -1,32 +1,49 @@
 import process from "node:process";
 import { promises as fs } from "node:fs";
+import { program } from "commander";
+
+program
+  .name("Cat")
+  .description("My version of cat command line tool")
+  .argument("<files...>", "Files to display")
+  .option("-n, --number", "Number all output lines")
+  .option("-b, --non-blank", "Number non empty output lines");
+
+program.parse();
+
+const { number, nonBlank } = program.opts();
+const filePaths = program.args;
 
-let args = process.argv.slice(2);
-const flags = args.filter((arg) => arg.startsWith("-"));
-const filePaths = args.filter((args) => !args.startsWith("-"));
 let lineNumber = 1;
 
 for (const filePath of filePaths) {
-  const content = await fs.readFile(filePath, "utf-8");
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
 
-  if (flags.length == 0) {
-    process.stdout.write(content);
-    continue;
-  }
-
-  const lines = content.split("\n");
+    if (!number && !nonBlank) {
+      process.stdout.write(content);
+      continue;
+    }
+    let text = content;
+    if (content.endsWith("\n")) {
+      text = content.slice(0, -1);
+    }
+    const lines = text.split("\n");
 
-  for (const line of lines) {
-    if (flags.includes("-b")) {
-      if (line === "") {
-        console.log();
-      } else {
+    for (const line of lines) {
+      if (nonBlank) {
+        if (line == "") {
+          console.log();
+        } else {
+          console.log(`${lineNumber}\t${line}`);
+          lineNumber++;
+        }
+      } else if (number) {
         console.log(`${lineNumber}\t${line}`);
         lineNumber++;
       }
-    } else if (flags.includes("-n")) {
-      console.log(`${lineNumber}\t${line}`);
-      lineNumber++;
     }
+  } catch (error) {
+    console.error(`${error}`);
   }
 }

implement-shell-tools/.DS_Store

@@ -1,22 +1,37 @@
 import process from "node:process";
 import { promises as fs } from "node:fs";
+import { program } from "commander";
 
-const args = process.argv.slice(2);
-const flags = args.filter((arg) => arg.startsWith("-"));
-const path = args.filter((arg) => !arg.startsWith("-"));
-let targetDir = path[0] || ".";
-let files = await fs.readdir(targetDir);
+program
+  .name("list")
+  .description("Implement my version of ls")
+  .argument("[paths...]", "The file path to process")
+  .option("-1, --one", "This list the item one per line")
+  .option("-a, --all", "This lists all of the files");
 
-if (flags.includes("-a")) {
-  files.unshift(".", "..");
-} else {
-  files = files.filter((fileName) => !fileName.startsWith("."));
-}
+program.parse();
+
+const { one, all } = program.opts();
+const paths = program.args;
+
+let targetDir = paths[0] || ".";
+
+try {
+  let files = await fs.readdir(targetDir);
+
+  if (all) {
+    files = [".", "..", ...files].sort();
+  } else {
+    files = files.filter((output) => !output.startsWith(".")).sort();
+  }
 
-if (flags.includes("-1")) {
-  for (const file of files) {
-    console.log(file);
+  if (one) {
+    for (const file of files) {
+      console.log(file);
+    }
+  } else {
+    console.log(files.join(" "));
   }
-} else {
-  console.log(files.join(" "));
+} catch (error) {
+  console.error(`${error}`);
 }

implement-shell-tools/cat/cat.mjs

@@ -0,0 +1,16 @@
+{
+  "name": "implement-shell-tools",
+  "version": "1.0.0",
+  "description": "Your task is to re-implement shell tools you have used.",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "commander": "^15.0.0"
+  }
+}

implement-shell-tools/ls/ls.mjs

@@ -1,33 +1,69 @@
 import process from "node:process";
 import { promises as fs } from "node:fs";
+import { program } from "commander";
 
-let filePaths = [];
-let flag = null;
-let numberOfWords;
+program
+  .name("Word Count")
+  .description("my implementation of wc")
+  .argument("<path...>", "The file path to process")
+  .option("-l", "Count for the total number of lines")
+  .option("-c", "Count the total number of bytes")
+  .option("-w", "Count the total number of words");
+
+program.parse();
+
+let filePaths = program.args;
+let options = program.opts();
+let noFlags = !options.l && !options.w && !options.c;
+
+let totalLines = 0;
+let totalWords = 0;
+let totalBytes = 0;
 
-if (process.argv[2].startsWith("-")) {
-  flag = process.argv[2];
-  filePaths = process.argv.slice(3);
-} else {
-  filePaths = process.argv.slice(2);
-}
 for (const filePath of filePaths) {
-  const content = await fs.readFile(filePath, "utf-8");
-
-  if (flag === "-w") {
-    console.log(getWordCount(content));
-  } else if (flag === "-l") {
-    console.log(getLineCount(content));
-  } else if (flag === "-c") {
-    console.log(getByteCount(content), filePaths);
-  } else {
-    console.log(
-      getWordCount(content),
-      getLineCount(content),
-      getByteCount(content),
-      filePaths,
-    );
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    const outputs = [];
+
+    const lines = getLineCount(content);
+    const words = getWordCount(content);
+    const bytes = getByteCount(content);
+
+    totalLines += lines;
+    totalWords += words;
+    totalBytes += bytes;
+
+    if (noFlags || options.l) {
+      outputs.push(lines);
+    }
+    if (noFlags || options.w) {
+      outputs.push(words);
+    }
+    if (noFlags || options.c) {
+      outputs.push(bytes);
+    }
+
+    outputs.push(filePath);
+    console.log(outputs.join("\t"));
+  } catch (err) {
+    console.error(`${err.message}`);
+  }
+}
+
+if (filePaths.length > 1) {
+  const totalOutputs = [];
+
+  if (noFlags || options.l) {
+    totalOutputs.push(totalLines);
+  }
+  if (noFlags || options.w) {
+    totalOutputs.push(totalWords);
+  }
+  if (noFlags || options.c) {
+    totalOutputs.push(totalBytes);
   }
+  totalOutputs.push("total");
+  console.log(totalOutputs.join("\t"));
 }
 
 function getWordCount(text) {