unforgit 0.4.0 → 0.5.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command30 } from "commander";
+import { Command as Command31 } from "commander";
 
 // src/commands/init.ts
 import fs2 from "fs";
@@ -3740,6 +3740,126 @@ async function runRemoteCurate(remoteUrl, options) {
   return client.runLifecycle(options);
 }
 
+// src/commands/suggestions.ts
+import { Command as Command30 } from "commander";
+import { getDbPath as getDbPath22, isInitialized as isInitialized18, loadConfig as loadConfig24 } from "unforgit-config";
+import { LocalStore as LocalStore21 } from "unforgit-db";
+import { generateSuggestions, persistReviewableSuggestions } from "unforgit-core";
+function openStore() {
+  if (!isInitialized18()) {
+    logger.error("Unforgit not initialized. Run 'unforgit init' first.");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const config = loadConfig24();
+  return {
+    config,
+    orgId: config.remote.orgId || "local",
+    repoId: config.remote.repoId || "local",
+    store: new LocalStore21(getDbPath22())
+  };
+}
+function formatSuggestionLine(suggestion) {
+  const memoryIds = suggestion.memoryIds.map((id) => id.slice(0, 8)).join(", ");
+  return [
+    `${suggestion.id.slice(0, 8)} [${suggestion.priority}] ${suggestion.type}`,
+    `  status: ${suggestion.status}`,
+    `  confidence: ${Math.round(suggestion.confidence * 100)}%`,
+    `  memories: ${memoryIds || "none"}`,
+    `  reason: ${suggestion.reason}`
+  ].join("\n");
+}
+function parseStatus(value) {
+  if (!value) return ["pending"];
+  const statuses = value.split(",").map((status) => status.trim()).filter(Boolean);
+  const allowed = /* @__PURE__ */ new Set(["pending", "approved", "rejected", "applied"]);
+  const invalid = statuses.find((status) => !allowed.has(status));
+  if (invalid) {
+    throw new Error(`Invalid suggestion status: ${invalid}`);
+  }
+  return statuses;
+}
+var suggestionsCommand = new Command30("suggestions").description("Reviewable curation suggestions inbox").addCommand(
+  new Command30("generate").description("Generate and persist pending review suggestions").option("--max <n>", "Maximum generated suggestions", (value) => Number.parseInt(value, 10), 20).option("--created-by <name>", "Actor name stored on generated suggestions", "cli").action((opts) => {
+    const { store, orgId, repoId } = openStore();
+    try {
+      const generated = generateSuggestions(store, orgId, repoId, {
+        maxSuggestions: opts.max
+      });
+      const persisted = persistReviewableSuggestions(
+        store,
+        orgId,
+        repoId,
+        generated.suggestions,
+        { createdBy: opts.createdBy }
+      );
+      const result = { ...generated.stats, ...persisted };
+      if (isJsonMode()) {
+        outputJson(result);
+        return;
+      }
+      logger.info(
+        `Generated ${generated.stats.suggestionsGenerated} suggestions; created ${persisted.created} pending review items; skipped ${persisted.skippedExisting} existing.`
+      );
+    } finally {
+      store.close();
+    }
+  })
+).addCommand(
+  new Command30("list").description("List curation suggestions by review status").option("--status <statuses>", "Comma-separated statuses (default: pending)").option("--limit <n>", "Maximum suggestions to show", (value) => Number.parseInt(value, 10), 20).action((opts) => {
+    const { store, orgId, repoId } = openStore();
+    try {
+      const status = parseStatus(opts.status);
+      const suggestions = store.listCurationSuggestions({
+        orgId,
+        repoId,
+        status,
+        limit: opts.limit
+      });
+      if (isJsonMode()) {
+        outputJson({ suggestions });
+        return;
+      }
+      const label = status?.join(",") ?? "all";
+      logger.info(`${label === "pending" ? "Pending" : label} curation suggestions`);
+      if (suggestions.length === 0) {
+        logger.info("No suggestions found.");
+        return;
+      }
+      for (const suggestion of suggestions) {
+        logger.info(formatSuggestionLine(suggestion));
+        logger.info("");
+      }
+    } finally {
+      store.close();
+    }
+  })
+).addCommand(
+  new Command30("review").description("Approve, reject, or mark a curation suggestion as applied").argument("<id>", "Suggestion id").option("--approve", "Mark suggestion as approved").option("--reject", "Mark suggestion as rejected").option("--applied", "Mark suggestion as applied").option("--reviewer <name>", "Reviewer name").option("--note <note>", "Review note").action((id, opts) => {
+    const selected = [opts.approve, opts.reject, opts.applied].filter(Boolean).length;
+    if (selected !== 1) {
+      logger.error("Choose exactly one of --approve, --reject, or --applied.");
+      process.exit(EXIT_ERROR);
+    }
+    const status = opts.approve ? "approved" : opts.reject ? "rejected" : "applied";
+    const { store } = openStore();
+    try {
+      const suggestion = store.reviewCurationSuggestion({
+        id,
+        status,
+        reviewedBy: opts.reviewer,
+        reviewNote: opts.note
+      });
+      if (isJsonMode()) {
+        outputJson(suggestion);
+        return;
+      }
+      logger.info(`Suggestion ${suggestion.id.slice(0, 8)} marked ${suggestion.status}.`);
+    } finally {
+      store.close();
+    }
+  })
+);
+
 // src/index.ts
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
@@ -3778,7 +3898,7 @@ process.on("unhandledRejection", (err) => {
   runCleanup();
   process.exit(EXIT_ERROR);
 });
-var program = new Command30();
+var program = new Command31();
 program.name("unforgit").description("Unforgit \u2014 repository memory for agents and developers").version(pkg.version).option("--verbose", "Enable verbose output").option("--quiet", "Suppress non-essential output").option("--json", "Output results as JSON (for scripting)").hook("preAction", () => {
   const opts = program.opts();
   if (opts.quiet) setVerbosity(0);
@@ -3819,6 +3939,7 @@ program.addCommand(backupsCommand);
 program.addCommand(dashboardCommand);
 program.addCommand(doctorCommand);
 program.addCommand(curateCommand);
+program.addCommand(suggestionsCommand);
 program.addCommand(completionCommand);
 program.parseAsync().catch((err) => {
   console.error(`fatal: ${err instanceof Error ? err.message : err}`);