@adithya-naik/cmd-tracker 1.0.0

package/src/utils/storage.js

@@ -0,0 +1,286 @@
+/*
+ * storage.js
+ *
+ * This file handles everything related to FILE OPERATIONS
+ * It saves commands, reads commands, and manages the .tracker folder
+ *
+ * Two files in Node.js help us work with files and folders:
+ * fs   → File System → read, write, check if file exists
+ * path → helps build file paths that work on ALL operating systems
+ *        Windows: C:\Users\project\.tracker\commands.json
+ *        Mac/Linux: /home/user/project/.tracker/commands.json
+ *        path module handles this difference automatically
+ */
+const fs = require("fs");
+const path = require("path");
+
+/*
+ * Import our categorize function from categorizer.js
+ * We need it here to know WHICH category to save the command in
+ */
+const { categorize } = require("./categorizer");
+
+/*
+ * process.cwd() → Current Working Directory
+ * This gives us the path of the folder where user ran the command
+ *
+ * Example:
+ * User is in → C:\Adithya Naik\GitHub\my-linux-repo
+ * process.cwd() → "C:\Adithya Naik\GitHub\my-linux-repo"
+ *
+ * This is VERY important — we want to save commands in THEIR repo
+ * not in our package folder
+ */
+const TRACKER_DIR = path.join(process.cwd(), ".tracker");
+
+/*
+ * This is where all commands will be saved
+ * .tracker/commands.json inside the user's repo
+ */
+const COMMANDS_FILE = path.join(TRACKER_DIR, "commands.json");
+
+/*
+ * This is our default empty structure
+ * When we create commands.json for the first time
+ * it starts with all empty arrays
+ *
+ * We use a function so we always get a FRESH object
+ * not the same object reused (important in JavaScript)
+ */
+function getDefaultStructure() {
+  return {
+    git: [],
+    npm: [],
+    docker: [],
+    linux: [],
+    node: [],
+    angular: [],
+    python: [],
+    others: [],
+  };
+}
+
+/*
+ * initStorage() — sets up the .tracker folder and commands.json
+ *
+ * This runs when user types: tracker init
+ * It creates the .tracker folder and commands.json if they don't exist
+ */
+function initStorage() {
+
+  /*
+   * fs.existsSync() → checks if a folder/file EXISTS
+   * Returns true if exists, false if not
+   *
+   * If .tracker folder doesn't exist → create it
+   */
+  if (!fs.existsSync(TRACKER_DIR)) {
+
+    /*
+     * fs.mkdirSync() → creates a folder
+     * { recursive: true } → creates parent folders too if needed
+     * Like "mkdir -p" in linux
+     */
+    fs.mkdirSync(TRACKER_DIR, { recursive: true });
+    console.log("✅ Created .tracker folder");
+  }
+
+  /*
+   * If commands.json doesn't exist → create it with default structure
+   */
+  if (!fs.existsSync(COMMANDS_FILE)) {
+
+    /*
+     * fs.writeFileSync() → creates and writes to a file
+     * JSON.stringify() → converts JavaScript object to JSON string
+     * null, 2 → makes the JSON nicely formatted with 2 spaces indent
+     */
+    fs.writeFileSync(
+      COMMANDS_FILE,
+      JSON.stringify(getDefaultStructure(), null, 2)
+    );
+    console.log("✅ Created .tracker/commands.json");
+  }
+}
+
+/*
+ * readCommands() — reads all saved commands from commands.json
+ *
+ * @returns {object} — the entire commands object with all categories
+ */
+function readCommands() {
+
+  /*
+   * If file doesn't exist yet — return empty structure
+   * This prevents crashes if someone runs tracker list before tracker init
+   */
+  if (!fs.existsSync(COMMANDS_FILE)) {
+    return getDefaultStructure();
+  }
+
+  /*
+   * fs.readFileSync() → reads the file content as text
+   * JSON.parse() → converts JSON text back to JavaScript object
+   */
+  const fileContent = fs.readFileSync(COMMANDS_FILE, "utf-8");
+  return JSON.parse(fileContent);
+}
+
+/*
+ * saveCommand() — saves a single command to commands.json
+ *
+ * @param {string} command — the terminal command to save
+ * @returns {object} — { saved: true/false, category: "git" etc, reason: "why not saved" }
+ */
+function saveCommand(command) {
+
+  /*
+   * Safety check — don't save empty commands
+   */
+  if (!command || !command.trim()) {
+    return { saved: false, reason: "empty command" };
+  }
+
+  /*
+   * Clean the command — remove extra spaces
+   */
+  const cleanCommand = command.trim();
+
+  /*
+   * Use our categorizer to find which category this command belongs to
+   */
+  const category = categorize(cleanCommand);
+
+  /*
+   * Read existing commands from file
+   */
+  const data = readCommands();
+
+  /*
+   * DUPLICATE CHECK
+   *
+   * .some() → loops through array and returns true if ANY item matches
+   *
+   * We check if this exact command already exists in this category
+   * If it does — don't save it again
+   *
+   * item.command → because each saved command is an object like:
+   * { command: "git status", time: "2026-05-06T..." }
+   */
+  const isDuplicate = data[category].some(
+    (item) => item.command === cleanCommand
+  );
+
+  if (isDuplicate) {
+    return { saved: false, reason: "duplicate", category };
+  }
+
+  /*
+   * Create the command object with timestamp
+   * new Date().toISOString() → "2026-05-06T10:30:00.000Z"
+   * This gives us a full date+time in standard format
+   */
+  const commandObject = {
+    command: cleanCommand,
+    time: new Date().toISOString(),
+  };
+
+  /*
+   * Push the new command into the correct category array
+   */
+  data[category].push(commandObject);
+
+  /*
+   * Write the updated data back to commands.json
+   */
+  fs.writeFileSync(COMMANDS_FILE, JSON.stringify(data, null, 2));
+
+  return { saved: true, category };
+}
+
+/*
+ * toggleFavorite() — marks/unmarks a command as favorite
+ *
+ * @param {string} command — the command to favorite
+ * @returns {object} — { success, action: "added"/"removed", command }
+ */
+function toggleFavorite(command) {
+
+  if (!command || !command.trim()) {
+    return { success: false, reason: "empty command" };
+  }
+
+  const cleanCommand = command.trim();
+  const data = readCommands();
+
+  /*
+   * Search for command across all categories
+   */
+  for (const [category, commands] of Object.entries(data)) {
+    const index = commands.findIndex(
+      (item) => item.command === cleanCommand
+    );
+
+    if (index !== -1) {
+      /*
+       * Toggle favorite flag
+       * If favorite exists and is true → set false
+       * If favorite doesn't exist or false → set true
+       */
+      const currentFav = data[category][index].favorite || false;
+      data[category][index].favorite = !currentFav;
+
+      fs.writeFileSync(COMMANDS_FILE, JSON.stringify(data, null, 2));
+
+      return {
+        success: true,
+        action: currentFav ? "removed" : "added",
+        command: cleanCommand,
+        category
+      };
+    }
+  }
+
+  return { success: false, reason: "command not found" };
+}
+
+/*
+ * getFavorites() — returns all favorited commands
+ *
+ * @returns {array} — array of { command, category, time }
+ */
+function getFavorites() {
+
+  const data = readCommands();
+  const favorites = [];
+
+  for (const [category, commands] of Object.entries(data)) {
+    for (const item of commands) {
+      if (item.favorite === true) {
+        favorites.push({
+          command: item.command,
+          category,
+          time: item.time
+        });
+      }
+    }
+  }
+
+  return favorites;
+}
+
+
+
+/*
+ * module.exports → expose these functions to other files
+ * Only export what other files need to use
+ */
+module.exports = {
+  initStorage,
+  readCommands,
+  saveCommand,
+  toggleFavorite,
+  getFavorites,
+  TRACKER_DIR,
+  COMMANDS_FILE,
+};

package/src/utils/validator.js

@@ -0,0 +1,94 @@
+/*
+ * validator.js
+ *
+ * Central validation utility for all commands
+ * Instead of repeating checks in every command file
+ * we put all validation logic here in one place
+ *
+ * This is called the DRY principle:
+ * DRY = Don't Repeat Yourself
+ * Write once, use everywhere ✅
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+/*
+ * Path to .tracker folder
+ * process.cwd() → user's current project folder
+ */
+const TRACKER_DIR = path.join(process.cwd(), ".tracker");
+const COMMANDS_FILE = path.join(TRACKER_DIR, "commands.json");
+
+/*
+ * isInitialized() — checks if tracker init was run
+ *
+ * Before any command works — .tracker/commands.json must exist
+ * If user skips tracker init and runs tracker list
+ * we catch it here and guide them
+ *
+ * @returns {boolean} — true if initialized, false if not
+ */
+function isInitialized() {
+  return fs.existsSync(TRACKER_DIR) && fs.existsSync(COMMANDS_FILE);
+}
+
+/*
+ * showInitError() — shows helpful error when not initialized
+ *
+ * Instead of a confusing crash — user sees a clear message
+ * telling them exactly what to do next
+ */
+function showInitError() {
+  console.log("\n❌ cmd-tracker is not initialized in this project!");
+  console.log("💡 Run this first: tracker init\n");
+}
+
+/*
+ * isValidCategory() — checks if category name is valid
+ *
+ * @param {string} category — category name to validate
+ * @returns {boolean} — true if valid, false if not
+ */
+function isValidCategory(category) {
+  const validCategories = [
+    "git", "npm", "docker", "linux",
+    "node", "angular", "python", "others"
+  ];
+  return validCategories.includes(category.toLowerCase());
+}
+
+/*
+ * showCategoryError() — shows helpful error for invalid category
+ *
+ * @param {string} category — the invalid category user typed
+ */
+function showCategoryError(category) {
+  console.log(`\n❌ Unknown category: "${category}"`);
+  console.log("📋 Valid categories: git, npm, docker, linux, node, angular, python, others\n");
+}
+
+/*
+ * isValidQuery() — checks if search query is valid
+ *
+ * @param {string} query — search term to validate
+ * @returns {boolean} — true if valid, false if not
+ */
+function isValidQuery(query) {
+  /*
+   * Query must exist and have at least 1 character after trimming
+   */
+  return query && query.trim().length > 0;
+}
+
+/*
+ * Export all validators
+ * Every command file will import what it needs from here
+ */
+module.exports = {
+  isInitialized,
+  showInitError,
+  isValidCategory,
+  showCategoryError,
+  isValidQuery
+};