@adithya-naik/cmd-tracker 1.0.0

package/src/commands/stats.js

@@ -0,0 +1,120 @@
+/*
+ * stats.js
+ *
+ * Handles "tracker stats" command
+ *
+ * Shows a breakdown of saved commands:
+ * → Total commands saved
+ * → Count per category
+ * → Percentage per category
+ * → Most used category
+ */
+
+const { readCommands } = require("../utils/storage");
+const { isInitialized, showInitError } = require("../utils/validator");
+
+function statsCommand() {
+
+  if (!isInitialized()) {
+    showInitError();
+    return;
+  }
+
+  try {
+    const data = readCommands();
+
+  /*
+   * Calculate total commands across all categories
+   * Object.values() → gets all arrays from data object
+   * .reduce() → adds up all lengths
+   *
+   * Example:
+   * { git: [1,2], npm: [1] } 
+   * → values → [[1,2], [1]]
+   * → reduce → 2 + 1 = 3
+   */
+  const total = Object.values(data).reduce(
+    (sum, commands) => sum + commands.length, 0
+  );
+
+    if (total === 0) {
+      console.log("\n📭 No commands saved yet!");
+      console.log("💡 Use: tracker save \"your command\"\n");
+      return;
+    }
+
+    console.log("\n📊 CMD-TRACKER — Statistics\n");
+    console.log("─".repeat(50));
+
+  /*
+   * Category icons — same as list.js for consistency
+   */
+  const icons = {
+    git:     "🔀",
+    npm:     "📦",
+    docker:  "🐳",
+    linux:   "🐧",
+    node:    "🟢",
+    angular: "🔴",
+    python:  "🐍",
+    others:  "📌"
+  };
+
+  /*
+   * Track which category has most commands
+   */
+  let topCategory = "";
+  let topCount = 0;
+
+  /*
+   * Loop through each category and show stats
+   */
+  for (const [category, commands] of Object.entries(data)) {
+
+    /*
+     * Skip empty categories
+     */
+    if (commands.length === 0) continue;
+
+    /*
+     * Calculate percentage
+     * Math.round() → rounds to nearest whole number
+     * 2.7 → 3, 2.3 → 2
+     */
+    const percentage = Math.round((commands.length / total) * 100);
+
+    /*
+     * Build a simple visual bar
+     * "█".repeat(percentage/5) → each block = 5%
+     * So 50% → 10 blocks, 100% → 20 blocks
+     */
+    const bar = "█".repeat(Math.round(percentage / 5));
+
+    const icon = icons[category] || "📌";
+
+    console.log(
+      `\n${icon}  ${category.toUpperCase().padEnd(10)} ` +
+      `${String(commands.length).padStart(3)} commands  ` +
+      `${String(percentage).padStart(3)}%  ${bar}`
+    );
+
+    /*
+     * Track top category
+     */
+    if (commands.length > topCount) {
+      topCount = commands.length;
+      topCategory = category;
+    }
+  }
+
+    console.log("\n" + "─".repeat(50));
+    console.log(`📦 Total commands : ${total}`);
+    console.log(`🏆 Most used      : ${topCategory} (${topCount} commands)\n`);
+
+  } catch (error) {
+    console.log("\n❌ Error reading statistics");
+    console.log("💡 Try running tracker init again\n");
+  }
+}
+
+module.exports = { statsCommand };

package/src/index.js

@@ -0,0 +1,19 @@
+/*
+ * index.js — Main entry point when package is required
+ *
+ * This file is used when someone does:
+ * const tracker = require('@adithya-naik/cmd-tracker')
+ *
+ * We export our core utilities so developers can
+ * use them programmatically in their own code
+ */
+
+const { saveCommand, readCommands, initStorage } = require("./utils/storage");
+const { categorize } = require("./utils/categorizer");
+
+module.exports = {
+  saveCommand,
+  readCommands,
+  initStorage,
+  categorize
+};

package/src/utils/categorizer.js

@@ -0,0 +1,165 @@
+/*
+ * categorizer.js
+ * 
+ * This file has ONE job — look at a command and decide its category
+ * Example:
+ *   "git status"      → "git"
+ *   "npm install"     → "npm"
+ *   "docker ps"       → "docker"
+ *   "ls -la"          → "linux"
+ *   "ng new my-app"   → "others"
+ */
+
+/*
+ * We define all our categories and their keywords here
+ * This is called a CONFIGURATION OBJECT
+ * 
+ * Why keep it here separately?
+ * → Easy to add new categories later
+ * → Easy to add new keywords to existing categories
+ * → Everything in one place — no hunting around in code
+ */
+const CATEGORIES = {
+
+  /*
+   * Any command starting with "git" goes here
+   * Examples: git status, git push, git commit -m "msg"
+   */
+  git: ["git"],
+
+  /*
+   * Any command starting with "npm" or "npx" goes here
+   * Examples: npm install, npm run dev, npx create-react-app
+   */
+  npm: ["npm", "npx"],
+
+  /*
+   * Any command starting with "docker" goes here
+   * Examples: docker ps, docker build, docker-compose up
+   */
+  docker: ["docker", "docker-compose"],
+
+  /*
+   * Common linux commands go here
+   * Examples: ls -la, cd projects, mkdir new-folder
+   */
+  linux: [
+    "ls",
+    "cd",
+    "pwd",
+    "mkdir",
+    "rm",
+    "cp",
+    "mv",
+    "cat",
+    "touch",
+    "chmod",
+    "chown",
+    "grep",
+    "find",
+    "echo",
+    "sudo",
+    "apt",
+    "curl",
+    "wget",
+    "nano",
+    "vim"
+  ],
+
+  /*
+   * Node.js related commands
+   * Examples: node index.js, nodemon server.js
+   */
+  node: ["node", "nodemon"],
+
+  /*
+   * Angular CLI commands
+   * Examples: ng new my-app, ng serve, ng generate component
+   */
+  angular: ["ng"],
+
+  /*
+   * Python commands
+   * Examples: python app.py, pip install flask
+   */
+  python: ["python", "python3", "pip", "pip3"],
+};
+
+/*
+ * categorize() — the main function of this file
+ * 
+ * It takes a command string as input
+ * It returns the category name as a string
+ * 
+ * @param {string} command - the terminal command typed by user
+ * @returns {string} - category name (git/npm/docker/linux/node/angular/python/others)
+ * 
+ * Example:
+ *   categorize("git status")  → "git"
+ *   categorize("npm install") → "npm"
+ *   categorize("ng serve")    → "angular"
+ *   categorize("abc xyz")     → "others"
+ */
+function categorize(command) {
+
+  /*
+   * Safety check — if command is empty or not a string, return "others"
+   * This prevents crashes if something unexpected is passed in
+   */
+  if (!command || typeof command !== "string") {
+    return "others";
+  }
+
+  /*
+   * .trim() → removes spaces from start and end
+   * .toLowerCase() → converts to lowercase so "Git Status" = "git status"
+   * .split(" ")[0] → takes only the FIRST word
+   * 
+   * Example:
+   *   "  git status  " → trim → "git status"
+   *                    → toLowerCase → "git status"
+   *                    → split(" ") → ["git", "status"]
+   *                    → [0] → "git"
+   */
+  const firstWord = command.trim().toLowerCase().split(" ")[0];
+
+  /*
+   * Object.entries() converts our CATEGORIES object into an array like:
+   * [
+   *   ["git", ["git"]],
+   *   ["npm", ["npm", "npx"]],
+   *   ...
+   * ]
+   * 
+   * We loop through each [categoryName, keywords] pair
+   */
+  for (const [categoryName, keywords] of Object.entries(CATEGORIES)) {
+
+    /*
+     * .includes() checks if our firstWord exists in the keywords array
+     * 
+     * Example:
+     *   categoryName = "npm"
+     *   keywords = ["npm", "npx"]
+     *   firstWord = "npx"
+     *   keywords.includes("npx") → true → return "npm"
+     */
+    if (keywords.includes(firstWord)) {
+      return categoryName;
+    }
+  }
+
+  /*
+   * If no category matched — return "others"
+   * This is our catch-all category
+   */
+  return "others";
+}
+
+/*
+ * module.exports → makes this function available to other files
+ * Without this line — no other file can use categorize()
+ * 
+ * This is how Node.js shares code between files
+ */
+module.exports = { categorize };

package/src/utils/hook.js

@@ -0,0 +1,281 @@
+/*
+ * hook.js
+ *
+ * This file handles the shell hook setup
+ * Shell hook = a small script added to user's shell config
+ * that runs automatically after EVERY command they type
+ *
+ * Supported shells:
+ * → bash → hooks into ~/.bashrc
+ * → zsh  → hooks into ~/.zshrc
+ * → Both are most common shells on Mac/Linux
+ *
+ * How it works:
+ * 1. Detect user's shell (bash or zsh)
+ * 2. Add a hook script to their shell config file
+ * 3. Hook script calls "tracker save <command>" after every command
+ * 4. User sources their config → automatic capture starts!
+ */
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+/*
+ * os module — built into Node.js
+ * os.homedir() → gives home directory path
+ * Windows → C:\Users\Adithya
+ * Mac/Linux → /home/adithya
+ */
+const HOME_DIR = os.homedir();
+
+/*
+ * Shell config file paths
+ * These are standard locations for shell config files
+ */
+const SHELL_CONFIGS = {
+  bash: path.join(HOME_DIR, ".bashrc"),
+  zsh: path.join(HOME_DIR, ".zshrc")
+};
+
+/*
+ * This is the actual hook script we add to shell config
+ * It runs after every command the user types
+ *
+ * How it works line by line:
+ *
+ * _cmd_tracker_hook() → defines a function
+ * LAST_CMD=$(history 1 | sed ...) → gets the last command typed
+ * tracker save "$LAST_CMD" → saves it using our CLI
+ *
+ * precmd() → zsh hook that runs before each prompt (zsh only)
+ * PROMPT_COMMAND → bash variable that runs before each prompt (bash only)
+ */
+/*
+ * HOOK_SCRIPT — the shell script we add to user's config
+ *
+ * IMPORTANT: We use regular string (single quotes) NOT template literal
+ * Because ${PROMPT_COMMAND} is a BASH variable not a JavaScript variable
+ * If we use backticks → JavaScript tries to read PROMPT_COMMAND as JS variable
+ * If we use regular string → it stays as plain text ✅
+ */
+/*
+ * HOOK_SCRIPT — shell script added to user's config
+ *
+ * The sed command had escaped quote issues before
+ * Fix: use [[:space:]] instead of [ ] and avoid nested quotes
+ * This is cleaner and works on all bash/zsh versions
+ */
+const HOOK_SCRIPT = [
+  "",
+  "# cmd-tracker shell hook — auto saves every command you type",
+  "_cmd_tracker_hook() {",
+  "  local LAST_CMD",
+  "  LAST_CMD=$(history 1 | sed 's/^[[:space:]]*[0-9]*[[:space:]]*//')",
+  '  if [ -n "$LAST_CMD" ]; then',
+  '    tracker save "$LAST_CMD" > /dev/null 2>&1',
+  "  fi",
+  "}",
+  "",
+  "# For zsh",
+  'if [ -n "$ZSH_VERSION" ]; then',
+  "  autoload -U add-zsh-hook",
+  "  add-zsh-hook precmd _cmd_tracker_hook",
+  "fi",
+  "",
+  "# For bash",
+  'if [ -n "$BASH_VERSION" ]; then',
+  '  PROMPT_COMMAND="_cmd_tracker_hook${PROMPT_COMMAND:+;$PROMPT_COMMAND}"',
+  "fi",
+  ""
+].join("\n");
+
+/*
+ * HOOK_MARKER — unique string we add to identify our hook
+ * We use this to:
+ * → Check if hook already exists (avoid duplicates)
+ * → Find and remove hook when user runs tracker unhook
+ */
+const HOOK_MARKER = "# cmd-tracker shell hook — auto saves every command you type";
+
+/*
+ * detectShell() — detects which shell user is running
+ *
+ * process.env.SHELL → environment variable containing shell path
+ * Example:
+ * "/bin/bash" → bash
+ * "/bin/zsh"  → zsh
+ *
+ * @returns {string} — "bash", "zsh", or "unknown"
+ */
+function detectShell() {
+  const shell = process.env.SHELL || "";
+
+  if (shell.includes("zsh")) return "zsh";
+  if (shell.includes("bash")) return "bash";
+
+  /*
+   * On Windows — check SHELL or ComSpec
+   * Most Windows users use bash via Git Bash
+   */
+  const comspec = process.env.ComSpec || "";
+  if (comspec.includes("cmd.exe")) return "unknown";
+
+  return "bash"; // default to bash
+}
+
+/*
+ * getConfigFile() — returns path to shell config file
+ *
+ * @param {string} shell — "bash" or "zsh"
+ * @returns {string} — full path to config file
+ */
+function getConfigFile(shell) {
+  return SHELL_CONFIGS[shell] || SHELL_CONFIGS.bash;
+}
+
+/*
+ * installHook() — adds hook script to shell config
+ *
+ * @returns {object} — { success: true/false, shell, configFile, message }
+ */
+function installHook() {
+
+  try {
+    const shell = detectShell();
+
+    /*
+     * If shell is unknown — we can't install hook
+     * This happens on Windows CMD/PowerShell
+     */
+    if (shell === "unknown") {
+      return {
+        success: false,
+        message: "❌ Automatic hook not supported on Windows CMD/PowerShell\n💡 Use Git Bash or WSL for automatic capture"
+      };
+    }
+
+    const configFile = getConfigFile(shell);
+
+    /*
+     * Check if hook already installed
+     * Look for our unique marker in the config file
+     */
+    if (fs.existsSync(configFile)) {
+      const content = fs.readFileSync(configFile, "utf-8");
+
+      if (content.includes(HOOK_MARKER)) {
+        return {
+          success: false,
+          message: `⚠️  Hook already installed in ${configFile}`
+        };
+      }
+    }
+
+    /*
+     * Append hook script to shell config file
+     * appendFileSync → adds to end without deleting existing content
+     */
+    fs.appendFileSync(configFile, HOOK_SCRIPT);
+
+    return {
+      success: true,
+      shell,
+      configFile,
+      message: `✅ Hook installed in ${configFile}`
+    };
+
+  } catch (error) {
+
+    if (error.code === "EACCES") {
+      return {
+        success: false,
+        message: "❌ Permission denied! Try with sudo/admin permissions"
+      };
+    }
+
+    return {
+      success: false,
+      message: `❌ Failed to install hook: ${error.message}`
+    };
+  }
+}
+
+/*
+ * removeHook() — removes hook script from shell config
+ *
+ * @returns {object} — { success: true/false, message }
+ */
+function removeHook() {
+
+  try {
+    const shell = detectShell();
+    const configFile = getConfigFile(shell);
+
+    if (!fs.existsSync(configFile)) {
+      return {
+        success: false,
+        message: "❌ Shell config file not found"
+      };
+    }
+
+    const content = fs.readFileSync(configFile, "utf-8");
+
+    /*
+     * Check if hook exists
+     */
+    if (!content.includes(HOOK_MARKER)) {
+      return {
+        success: false,
+        message: "⚠️  Hook not found in shell config"
+      };
+    }
+
+    /*
+     * Remove hook script from config
+     * Split by marker → take everything before it
+     * Then trim trailing whitespace
+     */
+    const newContent = content.split(HOOK_MARKER)[0].trimEnd() + "\n";
+    fs.writeFileSync(configFile, newContent);
+
+    return {
+      success: true,
+      configFile,
+      message: `✅ Hook removed from ${configFile}`
+    };
+
+  } catch (error) {
+    return {
+      success: false,
+      message: `❌ Failed to remove hook: ${error.message}`
+    };
+  }
+}
+
+/*
+ * isHookInstalled() — checks if hook is already installed
+ *
+ * @returns {boolean}
+ */
+function isHookInstalled() {
+  try {
+    const shell = detectShell();
+    const configFile = getConfigFile(shell);
+
+    if (!fs.existsSync(configFile)) return false;
+
+    const content = fs.readFileSync(configFile, "utf-8");
+    return content.includes(HOOK_MARKER);
+
+  } catch (error) {
+    return false;
+  }
+}
+
+module.exports = {
+  installHook,
+  removeHook,
+  isHookInstalled,
+  detectShell
+};