commentme 1.0.0

package/getcoms.js

@@ -0,0 +1,86 @@
+// import fs from "fs";
+
+// export function getAllComments() {
+//   if (!fs.existsSync("output.json")) {
+//     throw new Error("output.json not found. Run skim first.");
+//   }
+
+//   const raw = fs.readFileSync("output.json", "utf8");
+//   const comments = JSON.parse(raw);
+
+//   console.log(comments);
+// }
+// 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 getAllComments(filePath = null) {
+  const codebase = filePath ? path.basename(filePath) : "default";
+
+  // Check if user is logged in
+  try {
+    getCurrentUserId();
+  } catch (e) {
+    console.error(e.message);
+    return;
+  }
+
+  const session = getSession();
+  const token = session.token; // Try to get token if saved, though current saveSession only saves userId. 
+  // If auth middleware requires token, this needs to be updated. 
+  // However, the user instruction implies we just need to hit the API. 
+  // We'll pass the token in Authorization header if it exists.
+
+  try {
+    const response = await fetch(`${API_BASE_URL}/comments?codebase=${encodeURIComponent(codebase)}`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": token ? `Bearer ${token}` : "" // Sending token if available
+      }
+    });
+
+    const data = await response.json();
+
+    if (!response.ok) {
+      // Gracefully handle empty or error
+      if (response.status === 404) {
+        console.log("{}");
+        return;
+      }
+      throw new Error(data.message || "Failed to fetch comments");
+    }
+
+    console.log(data); // The API returns the comments object directly
+
+  } 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) {
+    console.log("{}");
+    return;
+  }
+
+  const codebaseIndex= store.comments.findIndex(c => c.codebase === codebase);
+
+  if (codebaseIndex === -1 || !store.comments[codebaseIndex].filecomment) {
+    console.log("{}");
+    return;
+  }
+  const codebaseEntry = store.comments[codebaseIndex];
+
+  console.log(Object.fromEntries(codebaseEntry.filecomment));
+  */
+}

package/getspeccoms.js

@@ -0,0 +1,101 @@
+// import fs from "fs";
+
+// export function getSpecificComment(key, silent = false) {
+//   if (!fs.existsSync("output.json")) {
+//     throw new Error("output.json not found. Run skim first.");
+//   }
+
+//   const raw = fs.readFileSync("output.json", "utf8");
+//   const comments = JSON.parse(raw);
+
+//   if (!comments[key]) {
+//     throw new Error(`No comment found for key: ${key}`);
+//   }
+
+//   if (!silent) {
+//     console.log(`✔ Comment for ${key}:`);
+//     console.log(comments[key]);
+//   }
+
+//   return comments[key]; // IMPORTANT for edit flow
+// }
+
+// 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 getSpecificComment(key, silent = false, filePath = null) {
+  const codebase = filePath ? path.basename(filePath) : "default";
+
+  // Check authentication
+  try {
+    getCurrentUserId();
+  } catch (e) {
+    if (!silent) console.error(e.message);
+    throw e;
+  }
+
+  const session = getSession();
+  const token = session ? session.token : null;
+
+  try {
+    const response = await fetch(`${API_BASE_URL}/comments/${encodeURIComponent(key)}?codebase=${encodeURIComponent(codebase)}`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": token ? `Bearer ${token}` : ""
+      }
+    });
+
+    const data = await response.json();
+
+    if (!response.ok) {
+      // Handle error, throw regular error to match previous behavior for catch blocks up the chain
+      throw new Error(data.message || `No comment found for key: ${key}`);
+    }
+
+    const value = data.comment; // Backend returns { key, comment }
+
+    if (!silent) {
+      console.log(`✔ Comment for ${key}:`);
+      console.log(value);
+    }
+
+    return value;
+
+  } catch (error) {
+    if (error.code === 'ECONNREFUSED') {
+      if (!silent) console.error("Error: Could not connect to the backend server. Is it running on port 8080?");
+      throw new Error("Connection failed");
+    } else {
+      // Re-throw so caller can handle "No comment found" etc.
+      throw error;
+    }
+  }
+
+  /*
+  const userId = getCurrentUserId();
+  const store = await CommentStore.findOne({ userId });
+
+  if (!store) {
+    throw new Error(`No comment found for key: ${key}`);
+  }
+
+  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];
+  const value = codebaseEntry.filecomment.get(key);
+
+  if (!silent) {
+    console.log(`✔ Comment for ${key}:`);
+    console.log(value);
+  }
+
+  return value;
+  */
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "commentme",
+  "version": "1.0.0",
+  "description": "A CLI tool to manage, redact and unredact your comments keeping the codebase clutterfree.",
+  "type": "module",
+  "bin": {
+    "commentme": "./bin/commentme.js"
+  },
+  "main": "bin/commentme.js",
+  "files": [
+    "bin/",
+    "utils/",
+    "config/",
+    "auth/",
+    "*.js"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "dotlasher",
+  "license": "MIT",
+  "dependencies": {
+    "acorn": "^8.15.0",
+    "bcryptjs": "^3.0.3",
+    "dotenv": "^17.2.3",
+    "mongoose": "^9.0.1"
+  }
+}

package/skimcoms.js

@@ -0,0 +1,221 @@
+// import * as acorn from "acorn";
+// import fs from "fs";
+
+// export function removeCommentsFromFile(filePath) {
+//   const code = fs.readFileSync(filePath, "utf8");
+
+//   const comments = [];
+//   const commentJSON = {};
+
+//   acorn.parse(code, {
+//     ecmaVersion: 2020,
+//     locations: true,
+//     onComment: (isBlock, text, start, end, startLoc, endLoc) => {
+//       comments.push({
+//         start,
+//         end,
+//         text,
+//         lineStart: startLoc.line,
+//         lineEnd: endLoc.line
+//       });
+//     }
+//   });
+
+//   for (const c of comments) {
+//     const key = `${c.lineStart}-${c.lineEnd}`;
+//     commentJSON[key] = c.text.trim();
+//   }
+
+//   comments.sort((a, b) => b.start - a.start);
+
+//   let cleaned = code;
+//   for (const c of comments) {
+//     cleaned = cleaned.slice(0, c.start) + cleaned.slice(c.end);
+//   }
+
+//   fs.writeFileSync(filePath, cleaned, "utf8");
+//   fs.writeFileSync("output.json", JSON.stringify(commentJSON, null, 2));
+
+//   return { cleaned, commentJSON };
+// }
+import * as acorn from "acorn";
+import fs from "fs";
+import path from "path";
+// import { CommentStore } from "./models/CommentStore.js";
+import { getSession } from "./utils/session.js";
+import { API_BASE_URL } from "./utils/config.js";
+import { getCurrentUserId } from "./utils/currentUser.js";
+import { getCommentPattern, detectComments, formatReferenceComment } from "./utils/commentPatterns.js";
+
+export async function removeCommentsFromFile(filePath, codebase = null) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  // Use filename as codebase if not provided
+  if (!codebase) {
+    codebase = path.basename(filePath);
+  }
+
+  // Check authentication
+  try {
+    getCurrentUserId();
+  } catch (e) {
+    console.error(e.message);
+    return;
+  }
+
+  const code = fs.readFileSync(filePath, "utf8");
+
+  const comments = [];
+  const commentMap = {};
+  const ext = path.extname(filePath).slice(1).toLowerCase();
+
+  // Use acorn for JavaScript files (more accurate), regex for others
+  if (ext === "js" || ext === "jsx" || ext === "ts" || ext === "tsx") {
+    try {
+      // Parse comments using acorn with module support
+      acorn.parse(code, {
+        ecmaVersion: 2020,
+        sourceType: "module",
+        locations: true,
+        onComment: (isBlock, text, start, end, startLoc, endLoc) => {
+          // Skip reference comments
+          if (text.trim().startsWith("#ref")) {
+            return;
+          }
+          comments.push({
+            start,
+            end,
+            text,
+            lineStart: startLoc.line,
+            lineEnd: endLoc.line,
+            isBlock: isBlock
+          });
+        }
+      });
+    } catch (e) {
+      // Clear half-populated comments from failed acorn parse
+      comments.length = 0;
+      // Fallback to regex-based detection if acorn fails (e.g., on JSX or TS syntax)
+      const pattern = getCommentPattern(filePath);
+      const detectedComments = detectComments(code, pattern);
+      comments.push(...detectedComments);
+    }
+  } else {
+    // Use regex-based detection for other file types
+    const pattern = getCommentPattern(filePath);
+    const detectedComments = detectComments(code, pattern);
+    comments.push(...detectedComments);
+  }
+
+  // Build key-value map
+  for (const c of comments) {
+    const key = `${c.lineStart}-${c.lineEnd}`;
+    commentMap[key] = c.text.trim();
+  }
+
+  // Replace comments with reference comments (descending order to preserve positions)
+  comments.sort((a, b) => b.start - a.start);
+
+  let result = code;
+  const pattern = getCommentPattern(filePath);
+
+  for (const c of comments) {
+    const key = `${c.lineStart}-${c.lineEnd}`;
+    const refComment = formatReferenceComment(key, pattern, c.isBlock);
+
+    if (c.isInline) {
+      // For inline comments: replace comment with reference, preserve code
+      // The slice already preserves code before (c.start is at comment start)
+      result = result.slice(0, c.start) + refComment + result.slice(c.end);
+    } else {
+      // Full line comment: replace entire comment
+      result = result.slice(0, c.start) + refComment + result.slice(c.end);
+    }
+  }
+
+  // Move file write after successful backend storage
+  const session = getSession();
+  const token = session ? session.token : null;
+
+  if (!token) {
+    throw new Error("Authentication token missing. Please log in again.");
+  }
+
+  try {
+    const response = await fetch(`${API_BASE_URL}/comments/upload`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`
+      },
+      body: JSON.stringify({ codebase: codebase, comments: commentMap })
+    });
+
+    const data = await response.json();
+
+    if (!response.ok) {
+      throw new Error(data.message || `Failed to upload comments for codebase: ${codebase}`);
+    }
+
+    // ONLY write the file after successful backup to the server
+    fs.writeFileSync(filePath, result, "utf8");
+    console.log(`✔ File skimmed and comments stored in database (codebase: ${codebase})`);
+
+  } catch (error) {
+    if (error.code === 'ECONNREFUSED') {
+      console.error("Error: Could not connect to the backend server. Is it running on Render?");
+    } else {
+      console.error("Error:", error.message);
+    }
+    // Return early to prevent returning the "successful" state
+    return;
+  }
+
+  /*
+  const userId = getCurrentUserId();
+
+  // 🔥 SAVE/UPDATE COMMENTS TO MONGODB
+  let store = await CommentStore.findOne({ userId });
+
+  if (!store) {
+    store = await CommentStore.create({ userId, comments: [] });
+  }
+
+  // Find codebase index
+  let codebaseIndex = store.comments.findIndex(c => c.codebase === codebase);
+  
+  if (codebaseIndex === -1) {
+    // Create new codebase entry
+    store.comments.push({
+      codebase,
+      filecomment: new Map()
+    });
+    codebaseIndex = store.comments.length - 1;
+    await store.save(); // Save to get the new entry properly initialized
+    store = await CommentStore.findById(store._id); // Re-fetch to get proper Mongoose document
+  }
+
+  // Get the codebase entry
+  const codebaseEntry = store.comments[codebaseIndex];
+  
+  // Ensure filecomment is a Map
+  if (!(codebaseEntry.filecomment instanceof Map)) {
+    codebaseEntry.filecomment = new Map(Object.entries(codebaseEntry.filecomment || {}));
+  }
+
+  // Update existing comments or add new ones
+  for (const [key, value] of Object.entries(commentMap)) {
+    codebaseEntry.filecomment.set(key, value);
+  }
+
+  // Mark as modified and save
+  store.markModified(`comments.${codebaseIndex}.filecomment`);
+  await store.save();
+
+  console.log(`✔ File skimmed and comments stored in database (codebase: ${codebase})`);
+  */
+
+  return { cleaned: result, commentMap };
+}

package/unskimcoms.js

@@ -0,0 +1,147 @@
+import fs from "fs";
+import path from "path";
+// import { CommentStore } from "./models/CommentStore.js";
+import { getCurrentUserId } from "./utils/currentUser.js";
+import { getSession } from "./utils/session.js";
+import { API_BASE_URL } from "./utils/config.js";
+import { getCommentPattern, formatComment } from "./utils/commentPatterns.js";
+
+export async function unskimComments(filePath, codebase = null) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  // Use filename as codebase if not provided
+  if (!codebase) {
+    codebase = path.basename(filePath);
+  }
+
+  // Check authentication
+  try {
+    getCurrentUserId();
+  } catch (e) {
+    console.error(e.message);
+    return;
+  }
+
+  const session = getSession();
+  const token = session ? session.token : null;
+  if (!token) {
+    throw new Error("Authentication token missing. Please log in again.");
+  }
+
+  let comments = {};
+
+  try {
+    const response = await fetch(`${API_BASE_URL}/comments?codebase=${encodeURIComponent(codebase)}`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`
+      }
+    });
+
+    const data = await response.json();
+
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw new Error(`No comments found for codebase: ${codebase}`);
+      }
+      throw new Error(data.message || `Failed to fetch comments for codebase: ${codebase}`);
+    }
+
+    comments = data;
+
+  } catch (error) {
+    if (error.code === 'ECONNREFUSED') {
+      console.error("Error: Could not connect to the backend server. Is it running on port 8080?");
+      return;
+    } else {
+      throw error;
+    }
+  }
+
+
+  /*
+  const userId = getCurrentUserId();
+
+  // Fetch comments from DB
+  const store = await CommentStore.findOne({ userId });
+
+  if (!store) {
+    throw new Error("No comments found for this user");
+  }
+
+  // Find the specific codebase
+  const codebaseEntry = store.comments.find(c => c.codebase === codebase);
+
+  if (!codebaseEntry) {
+    throw new Error(`No comments found for codebase: ${codebase}`);
+  }
+
+  // Ensure filecomment is a Map
+  let filecommentMap;
+  if (codebaseEntry.filecomment instanceof Map) {
+    filecommentMap = codebaseEntry.filecomment;
+  } else {
+    filecommentMap = new Map(Object.entries(codebaseEntry.filecomment || {}));
+  }
+
+  if (filecommentMap.size === 0) {
+    throw new Error(`No comments found for codebase: ${codebase}`);
+  }
+
+  const comments = Object.fromEntries(filecommentMap);
+  */
+
+  // Get comment pattern based on file extension
+  const pattern = getCommentPattern(filePath);
+
+  // Load file
+  const code = fs.readFileSync(filePath, "utf8");
+  let lines = code.split("\n");
+
+  // Replace reference comments with actual comments
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Match reference comment pattern (works for different comment styles, including block)
+    const refCommentMatch = line.match(/(\/\/|#|--|;|<!--|%|\/\*)\s*#ref\s+(\d+-\d+)\s*(-->|\*\/)?/);
+
+    if (refCommentMatch) {
+      const fullMatch = refCommentMatch[0];
+      const prefix = refCommentMatch[1];
+      const key = refCommentMatch[2];
+      const suffix = refCommentMatch[3] || "";
+      const commentText = comments[key];
+
+      if (commentText) {
+        let restoredComment = "";
+
+        if (prefix === "/*") {
+          // Mirror block comment style
+          restoredComment = `/* ${commentText} */`;
+        } else if (prefix === "<!--") {
+          // Mirror HTML comment style
+          restoredComment = `<!-- ${commentText} -->`;
+        } else {
+          // Default to line comment style
+          restoredComment = `${prefix} ${commentText}`;
+        }
+
+        // Replace only the reference part, preserving everything else on the line
+        lines[i] = line.replace(fullMatch, restoredComment);
+      } else {
+        // Key not found in DB - remove the reference comment part
+        lines[i] = line.replace(fullMatch, "").trimEnd();
+        // If line is now just whitespace, clear it to preserve line numbers if possible
+        if (lines[i].trim().length === 0) lines[i] = "";
+      }
+    }
+  }
+
+  // Write restored file
+  fs.writeFileSync(filePath, lines.join("\n"), "utf8");
+
+  console.log(`✔ Comments successfully restored from database (codebase: ${codebase})`);
+}