commentme 1.0.0

package/README.md

@@ -0,0 +1,55 @@
+# commentme
+
+A CLI tool to manage and store your cluttered-code comments and give the codebase a clean look. Extract comments from your code files, store them in a database, visit commentme platform for UI-friendly seek and restore your comments line-wise later.
+
+## Installation
+
+npm install -g commentme
+
+## Usage
+
+# Show help
+commentme --help
+
+# Login/Signup
+commentme --login
+commentme --signup
+
+# Get all comments
+commentme --get lines <file>
+
+# Get a specific comment
+commentme --get line-7-7 <file>
+
+
+# Edit a comment
+commentme --edit line-7-7 <file>
+
+# Delete a comment
+commentme --delete line-7-7 <file>
+
+# Redact comments from a file 
+commentme --skim <file>
+
+# Restore comments to a file
+commentme --unskim <file>
+
+# Logout
+commentme --logout
+
+## Features
+
+- Clutter-free and smooth codebase
+- Redact comments from files while keeping references
+- Restore comments back to files whenever required
+- User authentication and session management 
+- Per-codebase comment organization
+- Dedicated website for more UI friendly & AI edits on comments
+
+## Requirements
+
+- Node.js >= 18.0.0
+
+## License
+
+MIT

package/auth/authGuard.js

@@ -0,0 +1,23 @@
+import readline from "readline";
+import { getSession } from "../utils/session.js";
+import { signup } from "./signup.js";
+import { login } from "./login.js";
+
+export async function ensureAuth() {
+  const session = getSession();
+  if (session) return;
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const choice = await new Promise(res =>
+    rl.question("1. Login\n2. Signup\nChoose: ", res)
+  );
+  rl.close();
+
+  if (choice === "1") await login();
+  else if (choice === "2") await signup();
+  else throw new Error("Invalid choice");
+}

package/auth/login.js

@@ -0,0 +1,160 @@
+import readline from "readline";
+// import bcrypt from "bcryptjs";
+// import { User } from "../models/User.js";
+import { saveSession } from "../utils/session.js";
+import { promptPassword } from "../utils/passwordPrompt.js";
+import { API_BASE_URL } from "../utils/config.js";
+
+async function resetPassword() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const ask = q => new Promise(res => rl.question(q, res));
+
+  const identifier = await ask("Enter your username or email: ");
+  rl.close();
+
+  /*
+  // Try to find user by username or email
+  const user = await User.findOne({
+    $or: [
+      { username: identifier },
+      { email: identifier }
+    ]
+  });
+
+  if (!user) {
+    throw new Error("User not found with that username or email");
+  }
+  */
+
+  // console.log("User found. Please enter your new password.");
+  const new_password = await promptPassword("New Password: ");
+  const confirm_password = await promptPassword("Confirm New Password: ");
+
+  if (new_password !== confirm_password) {
+    throw new Error("Passwords do not match");
+  }
+
+  if (new_password.length === 0) {
+    throw new Error("Password cannot be empty");
+  }
+
+  /*
+  const hashed = await bcrypt.hash(newPassword, 10);
+  user.password = hashed;
+  await user.save();
+
+  console.log("✔ Password reset successful");
+  console.log("✔ You can now login with your new password");
+  */
+
+  try {
+    const response = await fetch(`${API_BASE_URL}/forgot-password`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ "identifier": identifier, "newPassword": new_password, "confirmPassword": confirm_password }),
+    });
+
+    const data = await response.json();
+
+    if (!response.ok) {
+      throw new Error(data.message || "Password reset failed");
+    }
+
+    console.log("✔ Password reset successful");
+    console.log("✔ You can now login with your new password");
+  } catch (error) {
+    if (error.code === 'ECONNREFUSED') {
+      console.error("Error: Could not connect to the backend server. Is it running on port 8080?");
+      throw new Error("Connection Refused");
+    } else {
+      throw error;
+    }
+  }
+}
+
+export async function login() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const ask = q => new Promise(res => rl.question(q, res));
+
+  const choice = await ask("1. Login\n2. Forgot Password\nChoose: ");
+  rl.close();
+
+  if (choice === "2") {
+    try {
+      await resetPassword();
+      return;
+    } catch (error) {
+      // console.error(`✗ ${error.message}`);
+      throw error;
+    }
+  }
+
+  if (choice !== "1") {
+    throw new Error("Invalid choice");
+  }
+
+  // Create a new readline interface for username input
+  const rl2 = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const ask2 = q => new Promise(res => rl2.question(q, res));
+  const username = await ask2("Username: ");
+  rl2.close();
+
+  const password = await promptPassword("Password: ");
+
+  /*
+  const user = await User.findOne({ username });
+  if (!user) throw new Error("User not found");
+
+  const ok = await bcrypt.compare(password, user.password);
+  if (!ok) throw new Error("Invalid password");
+
+  saveSession(user._id);
+  console.log("✔ Login successful");
+  console.log("✔ Process ran successful");
+  */
+
+  try {
+    const response = await fetch(`${API_BASE_URL}/login`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ username, password }),
+    });
+
+    const data = await response.json();
+
+    if (!response.ok) {
+      throw new Error(data.message || "Login failed");
+    }
+
+    saveSession({
+      ...data,
+      token: data.accessToken
+    });
+    console.log("✔ Login successful");
+    console.log("✔ Process ran successful");
+  } catch (error) {
+    if (error.code === 'ECONNREFUSED') {
+      console.error("Error: Could not connect to the backend server. Is it running on port 8080?");
+      throw new Error("Connection Refused");
+    } else {
+      throw error;
+    }
+  }
+
+}

package/auth/logout.js

@@ -0,0 +1,6 @@
+import { clearSession } from "../utils/session.js";
+
+export function logout() {
+  clearSession();
+  console.log("✔ Logged out successfully");
+}

package/auth/signup.js

@@ -0,0 +1,71 @@
+import readline from "readline";
+// import bcrypt from "bcryptjs";
+// import { User } from "../models/User.js";
+import { saveSession } from "../utils/session.js";
+import { promptPassword } from "../utils/passwordPrompt.js";
+import { API_BASE_URL } from "../utils/config.js";
+
+//signup function
+export async function signup() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const ask = q => new Promise(res => rl.question(q, res));
+
+  const username = await ask("Username: ");
+  const email = await ask("Email: ");
+  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
+    console.log("Invalid email address");
+    rl.close();
+    return;
+  }
+
+  // const existinguser = await User.findOne({ email });
+  // if (existinguser) {
+  //   console.log("User already exists, Try logging in");
+  //   rl.close(); 
+  //   return;
+  // }
+  rl.close();
+
+  const password = await promptPassword("Password: ");
+
+  try {
+    const response = await fetch(`${API_BASE_URL}/signup`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ username, email, password }),
+    });
+
+    const data = await response.json();
+
+    if (!response.ok) {
+      throw new Error(data.message || "Signup failed");
+    }
+
+    // saveSession({
+    //   ...data,
+    //   token: data.accessToken
+    // });
+
+    console.log("✔ Signup successful");
+    console.log("👉 Please run 'commentme --login' to authenticate.");
+  } catch (error) {
+    if (error.code === 'ECONNREFUSED') {
+      console.error("Error: Could not connect to the backend server. Is it running on port 8080?");
+    } else {
+      console.error("Error:", error.message);
+    }
+  }
+
+  // const hashed = await bcrypt.hash(password, 10);
+  // const user = await User.create({ username, email, password: hashed });
+
+  // saveSession(user._id);
+  // console.log("✔ Signup successful");
+  // console.log("✔ Process ran successful");
+}

package/bin/commentme.js

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+
+
+import readline from "readline";
+import { getAllComments } from "../getcoms.js";
+import { getSpecificComment } from "../getspeccoms.js";
+import { editComment } from "../editcoms.js";
+import { deleteComment } from "../deletecoms.js";
+import { removeCommentsFromFile as skim } from "../skimcoms.js";
+import { unskimComments as unskim } from "../unskimcoms.js";
+// import { connectDB, disconnectDB } from "../config/db.js";
+import { ensureAuth } from "../auth/authGuard.js";
+import { logout } from "../auth/logout.js";
+import dotenv from "dotenv";
+dotenv.config();
+
+function promptInput(defaultValue = "") {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise(resolve => {
+    rl.question("> ", answer => {
+      rl.close();
+      resolve(answer || defaultValue);
+    });
+  });
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  try {
+    // Show help without connecting to DB or requiring auth
+    if (command === "--help" || command === "-h" || !command) {
+      console.log(`
+commentme CLI
+
+Commands:
+  commentme --get line-7-7 <file>      Get a specific comment by line range
+  commentme --get lines <file>         Get all comments
+  commentme --edit line-7-7 <file>      Edit an existing comment
+  commentme --delete line-7-7 <file>    Delete a comment
+  commentme --skim <file>        Redact comments from a file and store them
+  commentme --unskim <file>      Restore comments to a file
+  commentme --logout             Log out from your session
+  commentme --help               Show this help message
+`);
+      return;
+    }
+
+    /*
+    await connectDB();
+    */
+
+    // 🔐 Skip auth ONLY for logout
+    // 🔐 Skip auth for logout, login, and signup
+    if (command !== "--logout" && command !== "--login" && command !== "--signup") {
+      await ensureAuth();
+    }
+
+    switch (command) {
+      case "--login":
+        await import("../auth/login.js").then(m => m.login());
+        break;
+
+      case "--signup":
+        await import("../auth/signup.js").then(m => m.signup());
+        break;
+
+      case "--logout":
+
+      case "--get":
+        if (args[1] === "lines" && args[2]) {
+          await getAllComments(args[2]);
+        } else {
+          const key = args[1]?.replace("line-", "");
+          if (!key) throw new Error("Usage: commentme --get line-1-6");
+          await getSpecificComment(key, false, args[2]);
+        }
+        break;
+
+
+      case "--edit": {
+        const key = args[1]?.replace("line-", "");
+        if (!key) throw new Error("Usage: commentme --edit line-1-6");
+
+        const existing = await getSpecificComment(key, true, args[2]);
+        console.log("Edit comment:");
+        const updated = await promptInput(existing);
+        await editComment(key, updated, args[2]);
+        break;
+      }
+
+      case "--delete": {
+        const key = args[1]?.replace("line-", "");
+        if (!key) throw new Error("Usage: commentme --delete line-1-6");
+        await deleteComment(key, args[2]);
+        break;
+      }
+
+      case "--skim":
+        if (!args[1]) throw new Error("Usage: commentme --skim <file>");
+        await skim(args[1]);
+        break;
+
+      case "--unskim":
+        if (!args[1]) throw new Error("Usage: commentme --unskim <file>");
+        await unskim(args[1]);
+        break;
+
+      case "--logout":
+        logout();
+        break;
+
+      default:
+        console.log(`
+commentme CLI
+
+Commands:
+  commentme --login
+  commentme --signup
+  commentme --get line-7-7 <file>
+  commentme --get lines <file>
+  commentme --edit line-7-7 <file>
+  commentme --delete line-7-7 <file>
+  commentme --skim <file>
+  commentme --unskim <file>
+  commentme --logout
+`);
+    }
+
+  } catch (err) {
+    console.error("❌", err.message);
+  } finally {
+    /*
+    if (command !== "--help" && command !== "-h" && command) {
+      await disconnectDB();
+    }
+    */
+    process.exit(0);
+  }
+}
+
+main();

package/config/db.js

@@ -0,0 +1,19 @@
+// import mongoose from "mongoose";
+
+// export async function connectDB() {
+//   const mongoUri = process.env.MONGODB_URI;
+  
+//   if (!mongoUri) {
+//     throw new Error("MONGODB_URI environment variable is not set. Please create a .env file with your MongoDB connection string.");
+//   }
+  
+//   await mongoose.connect(mongoUri);
+  
+//   console.log("✔ Connected to MongoDB");
+// }
+
+// export async function disconnectDB() {
+//   await mongoose.disconnect();
+//   console.log("✔ Disconnected from MongoDB");
+// }
+

package/deletecoms.js

@@ -0,0 +1,96 @@
+// import fs from "fs";
+
+// export function deleteComment(key) {
+//   // Check that output.json exists
+//   if (!fs.existsSync("output.json")) {
+//     console.error("❌ output.json not found. Run skimcoms.js first.");
+//     process.exit(1);
+//   }
+
+//   // Load and parse JSON
+//   const raw = fs.readFileSync("output.json", "utf8");
+//   const comments = JSON.parse(raw);
+
+//   // Check if this key exists
+//   if (!comments[key]) {
+//     console.error(`❌ No comment found for key: ${key}`);
+//     process.exit(1);
+//   }
+
+//   // Delete the entry
+//   delete comments[key];
+
+//   // Save updated JSON back to file
+//   fs.writeFileSync("output.json", JSON.stringify(comments, null, 2));
+
+//   console.log(`✔ Comment for key ${key} has been deleted.`);
+// }
+
+
+// import { CommentStore } from "./models/CommentStore.js";
+import path from "path";
+import { getCurrentUserId } from "./utils/currentUser.js";
+import { getSession } from "./utils/session.js";
+import { API_BASE_URL } from "./utils/config.js";
+
+export async function deleteComment(key, filePath = null) {
+  const codebase = filePath ? path.basename(filePath) : "default";
+
+  // Check authentication
+  try {
+    getCurrentUserId();
+  } catch (e) {
+    console.error(e.message);
+    return;
+  }
+
+  const session = getSession();
+  const token = session ? session.token : null;
+
+  try {
+    const response = await fetch(`${API_BASE_URL}/comments/${encodeURIComponent(key)}?codebase=${encodeURIComponent(codebase)}`, {
+      method: "DELETE",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": token ? `Bearer ${token}` : ""
+      }
+    });
+
+    const data = await response.json();
+
+    if (!response.ok) {
+      throw new Error(data.message || `Failed to delete comment for key: ${key}`);
+    }
+
+    console.log(`✔ Comment deleted for ${key}`);
+
+  } catch (error) {
+    if (error.code === 'ECONNREFUSED') {
+      console.error("Error: Could not connect to the backend server. Is it running on port 8080?");
+    } else {
+      console.error("Error:", error.message);
+    }
+  }
+
+  /*
+  const userId = getCurrentUserId();
+
+  const store = await CommentStore.findOne({ userId });
+
+  if (!store) {
+    throw new Error("No comments found");
+  }
+  
+  const codebaseIndex = store.comments.findIndex(c => c.codebase === codebase);
+
+  if (codebaseIndex === -1 || !store.comments[codebaseIndex].filecomment) {
+    throw new Error(`No comment found for key: ${key}`);
+  }
+
+  const codebaseEntry = store.comments[codebaseIndex];
+  codebaseEntry.filecomment.delete(key);
+  await store.save();
+
+  console.log(`✔ Comment deleted for ${key}`);
+  */
+}

package/editcoms.js

@@ -0,0 +1,97 @@
+// import fs from "fs";
+
+// export function editComment(key, newText) {
+//   // Ensure output.json exists
+//   if (!fs.existsSync("output.json")) {
+//     console.error("❌ output.json not found. Run skimcoms.js first.");
+//     process.exit(1);
+//   }
+
+//   // Read and parse the file
+//   const raw = fs.readFileSync("output.json", "utf8");
+//   const comments = JSON.parse(raw);
+
+//   // Check if key exists
+//   if (!comments[key]) {
+//     console.error(`❌ No comment found for key: ${key}`);
+//     process.exit(1);
+//   }
+
+//   // Update the value
+//   comments[key] = newText.trim();
+
+//   // Write updated data back to output.json
+//   fs.writeFileSync("output.json", JSON.stringify(comments, null, 2));
+
+//   console.log(`✔ Comment for key ${key} successfully updated.`);
+//   console.log(`🆕 New comment: ${comments[key]}`);
+// }
+
+
+// import { CommentStore } from "./models/CommentStore.js";
+import path from "path";
+import { getCurrentUserId } from "./utils/currentUser.js";
+import { getSession } from "./utils/session.js";
+import { API_BASE_URL } from "./utils/config.js";
+
+export async function editComment(key, value, filePath = null) {
+  const codebase = filePath ? path.basename(filePath) : "default";
+
+  // Check authentication
+  try {
+    getCurrentUserId();
+  } catch (e) {
+    console.error(e.message);
+    return;
+  }
+
+  const session = getSession();
+  const token = session ? session.token : null;
+
+  try {
+    const response = await fetch(`${API_BASE_URL}/comments/${encodeURIComponent(key)}?codebase=${encodeURIComponent(codebase)}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": token ? `Bearer ${token}` : ""
+      },
+      body: JSON.stringify({ value })
+    });
+
+    const data = await response.json();
+
+    if (!response.ok) {
+      throw new Error(data.message || `Failed to update comment for key: ${key}`);
+    }
+
+    console.log(`✔ Comment updated for ${key}`);
+
+  } catch (error) {
+    if (error.code === 'ECONNREFUSED') {
+      console.error("Error: Could not connect to the backend server. Is it running on port 8080?");
+    } else {
+      console.error("Error:", error.message);
+    }
+  }
+
+  /*
+  const userId = getCurrentUserId();
+
+  const store = await CommentStore.findOne({ userId });
+
+  if (!store) {
+    throw new Error("No comments found");
+  }
+
+  const codebaseIndex = store.comments.findIndex(c => c.codebase === codebase);
+
+  if (codebaseIndex === -1 || !store.comments[codebaseIndex].filecomment.has(key)) {
+    throw new Error(`No comment found for key: ${key}`);
+  }
+  const codebaseEntry = store.comments[codebaseIndex];
+  codebaseEntry.filecomment.set(key, value);
+  await store.save();
+
+  console.log(`✔ Comment updated for ${key}`);
+  */
+}