chainlesschain 0.37.9 → 0.37.10

package/src/commands/memory.js

@@ -0,0 +1,282 @@
+/**
+ * Persistent memory management commands
+ * chainlesschain memory show|add|search|daily|file
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  getMemoryDir,
+  addMemory,
+  searchMemory,
+  listMemory,
+  deleteMemory,
+  appendDailyNote,
+  getDailyNote,
+  listDailyNotes,
+  getMemoryFile,
+  updateMemoryFile,
+} from "../lib/memory-manager.js";
+
+export function registerMemoryCommand(program) {
+  const memory = program
+    .command("memory")
+    .description("Persistent memory and daily notes");
+
+  // memory show
+  memory
+    .command("show", { isDefault: true })
+    .description("Show memory entries")
+    .option("-n, --limit <n>", "Max entries", "20")
+    .option("--category <cat>", "Filter by category")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const entries = listMemory(db, {
+          limit: Math.max(1, parseInt(options.limit) || 20),
+          category: options.category,
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(entries, null, 2));
+        } else if (entries.length === 0) {
+          logger.info("No memory entries. Use 'memory add' to create one.");
+        } else {
+          logger.log(chalk.bold(`Memory (${entries.length} entries):\n`));
+          for (const e of entries) {
+            const stars =
+              "★".repeat(e.importance) + "☆".repeat(5 - e.importance);
+            logger.log(
+              `  ${chalk.gray(e.id.slice(0, 12))}  ${chalk.yellow(stars)}  ${chalk.cyan(e.category)}`,
+            );
+            logger.log(
+              `    ${chalk.white(e.content.substring(0, 120).replace(/\n/g, " "))}`,
+            );
+            logger.log(`    ${chalk.gray(e.created_at)}`);
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // memory add
+  memory
+    .command("add")
+    .description("Add a memory entry")
+    .argument("<text>", "Memory content")
+    .option("--category <cat>", "Category", "general")
+    .option("--importance <n>", "Importance 1-5", "3")
+    .option("--json", "Output as JSON")
+    .action(async (text, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const entry = addMemory(db, text, {
+          category: options.category,
+          importance: Math.max(
+            1,
+            Math.min(5, parseInt(options.importance) || 3),
+          ),
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(entry, null, 2));
+        } else {
+          logger.success(
+            `Memory added: ${chalk.gray(entry.id.slice(0, 12))} [${chalk.cyan(entry.category)}]`,
+          );
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // memory search
+  memory
+    .command("search")
+    .description("Search memory entries")
+    .argument("<query>", "Search query")
+    .option("-n, --limit <n>", "Max results", "20")
+    .option("--json", "Output as JSON")
+    .action(async (query, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const results = searchMemory(db, query, {
+          limit: Math.max(1, parseInt(options.limit) || 20),
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(results, null, 2));
+        } else if (results.length === 0) {
+          logger.info(`No memory entries matching "${query}"`);
+        } else {
+          logger.log(
+            chalk.bold(
+              `Memory search "${query}" (${results.length} results):\n`,
+            ),
+          );
+          for (const e of results) {
+            logger.log(
+              `  ${chalk.gray(e.id.slice(0, 12))}  ${chalk.cyan(e.category)}  ${chalk.gray(e.created_at)}`,
+            );
+            logger.log(
+              `    ${chalk.white(e.content.substring(0, 120).replace(/\n/g, " "))}`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // memory delete
+  memory
+    .command("delete")
+    .description("Delete a memory entry")
+    .argument("<id>", "Entry ID (or prefix)")
+    .action(async (id) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const ok = deleteMemory(db, id);
+        if (ok) {
+          logger.success("Memory entry deleted");
+        } else {
+          logger.error(`Memory entry not found: ${id}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // memory daily
+  memory
+    .command("daily")
+    .description("View or append to daily notes")
+    .argument("[date]", "Date (YYYY-MM-DD, default: today)")
+    .option("-a, --append <text>", "Append text to daily note")
+    .option("--list", "List available daily notes")
+    .option("--json", "Output as JSON")
+    .action(async (date, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const memoryDir = getMemoryDir(ctx.env.dataDir);
+
+        if (options.list) {
+          const notes = listDailyNotes(memoryDir);
+          if (options.json) {
+            console.log(JSON.stringify(notes, null, 2));
+          } else if (notes.length === 0) {
+            logger.info("No daily notes yet");
+          } else {
+            logger.log(chalk.bold("Daily Notes:\n"));
+            for (const n of notes) {
+              logger.log(
+                `  ${chalk.cyan(n.date)}  ${chalk.gray(n.size + " bytes")}`,
+              );
+            }
+          }
+          await shutdown();
+          return;
+        }
+
+        if (options.append) {
+          const result = appendDailyNote(memoryDir, options.append);
+          logger.success(`Added to daily note: ${chalk.cyan(result.date)}`);
+          await shutdown();
+          return;
+        }
+
+        // Show daily note
+        const targetDate = date || new Date().toISOString().slice(0, 10);
+        const content = getDailyNote(memoryDir, targetDate);
+
+        if (!content) {
+          logger.info(`No daily note for ${targetDate}`);
+        } else if (options.json) {
+          console.log(JSON.stringify({ date: targetDate, content }, null, 2));
+        } else {
+          logger.log(content);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // memory file
+  memory
+    .command("file")
+    .description("View or edit the long-term MEMORY.md file")
+    .option("--edit", "Open in $EDITOR")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const memoryDir = getMemoryDir(ctx.env.dataDir);
+        const content = getMemoryFile(memoryDir);
+
+        if (options.edit) {
+          const { execSync } = await import("child_process");
+          const editor = process.env.EDITOR || process.env.VISUAL || "nano";
+          const filePath = `${memoryDir}/MEMORY.md`;
+          try {
+            execSync(`${editor} "${filePath}"`, { stdio: "inherit" });
+            logger.success("Memory file updated");
+          } catch {
+            logger.error(
+              `Failed to open editor. Set $EDITOR environment variable.`,
+            );
+          }
+        } else if (options.json) {
+          console.log(JSON.stringify({ content }, null, 2));
+        } else if (!content) {
+          logger.info(
+            "MEMORY.md is empty. Use 'memory file --edit' to add content.",
+          );
+        } else {
+          logger.log(content);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/note.js

@@ -6,6 +6,15 @@
 import chalk from "chalk";
 import { logger } from "../lib/logger.js";
 import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  ensureVersionsTable,
+  saveVersion,
+  getHistory,
+  getVersion,
+  simpleDiff,
+  formatDiff,
+  revertToVersion,
+} from "../lib/note-versioning.js";
 
 /**
  * Ensure the notes table exists in the database
@@ -299,4 +308,182 @@ export function registerNoteCommand(program) {
         process.exit(1);
       }
     });
+
+  // note history
+  note
+    .command("history")
+    .description("Show version history for a note")
+    .argument("<id>", "Note ID (or prefix)")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+
+        const rawDb = ctx.db.getDatabase();
+        ensureNotesTable(rawDb);
+        ensureVersionsTable(rawDb);
+
+        // Find the note
+        const noteRow = rawDb
+          .prepare(
+            "SELECT id FROM notes WHERE id LIKE ? AND deleted_at IS NULL",
+          )
+          .get(`${id}%`);
+
+        if (!noteRow) {
+          logger.error(`Note not found: ${id}`);
+          process.exit(1);
+        }
+
+        const history = getHistory(rawDb, noteRow.id);
+
+        if (options.json) {
+          console.log(JSON.stringify(history, null, 2));
+        } else if (history.length === 0) {
+          logger.info("No version history found");
+        } else {
+          logger.log(
+            chalk.bold(`Version history (${history.length} versions):\n`),
+          );
+          for (const v of history) {
+            logger.log(
+              `  ${chalk.cyan(`v${v.version}`)}  ${chalk.white(v.title)}  ${chalk.gray(v.change_type)}  ${chalk.gray(v.created_at || "")}`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed to get history: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // note diff
+  note
+    .command("diff")
+    .description("Show diff between two versions of a note")
+    .argument("<id>", "Note ID (or prefix)")
+    .argument("<v1>", "First version number")
+    .argument("<v2>", "Second version number")
+    .option("--json", "Output as JSON")
+    .action(async (id, v1, v2, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+
+        const rawDb = ctx.db.getDatabase();
+        ensureNotesTable(rawDb);
+        ensureVersionsTable(rawDb);
+
+        const noteRow = rawDb
+          .prepare(
+            "SELECT id FROM notes WHERE id LIKE ? AND deleted_at IS NULL",
+          )
+          .get(`${id}%`);
+
+        if (!noteRow) {
+          logger.error(`Note not found: ${id}`);
+          process.exit(1);
+        }
+
+        const ver1 = getVersion(rawDb, noteRow.id, parseInt(v1));
+        const ver2 = getVersion(rawDb, noteRow.id, parseInt(v2));
+
+        if (!ver1) {
+          logger.error(`Version ${v1} not found`);
+          process.exit(1);
+        }
+        if (!ver2) {
+          logger.error(`Version ${v2} not found`);
+          process.exit(1);
+        }
+
+        const diff = simpleDiff(ver1.content, ver2.content);
+
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              { v1: parseInt(v1), v2: parseInt(v2), diff },
+              null,
+              2,
+            ),
+          );
+        } else {
+          logger.log(chalk.bold(`Diff: v${v1} → v${v2}\n`));
+          logger.log(formatDiff(diff));
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed to compute diff: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // note revert
+  note
+    .command("revert")
+    .description("Revert a note to a specific version")
+    .argument("<id>", "Note ID (or prefix)")
+    .argument("<version>", "Version number to revert to")
+    .option("--force", "Skip confirmation")
+    .action(async (id, version, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+
+        const rawDb = ctx.db.getDatabase();
+        ensureNotesTable(rawDb);
+        ensureVersionsTable(rawDb);
+
+        const noteRow = rawDb
+          .prepare(
+            "SELECT id, title FROM notes WHERE id LIKE ? AND deleted_at IS NULL",
+          )
+          .get(`${id}%`);
+
+        if (!noteRow) {
+          logger.error(`Note not found: ${id}`);
+          process.exit(1);
+        }
+
+        if (!options.force) {
+          const { confirm } = await import("@inquirer/prompts");
+          const ok = await confirm({
+            message: `Revert note "${noteRow.title}" to version ${version}?`,
+          });
+          if (!ok) {
+            logger.info("Cancelled");
+            return;
+          }
+        }
+
+        const result = revertToVersion(rawDb, noteRow.id, parseInt(version));
+
+        if (!result) {
+          logger.error(`Version ${version} not found or note unavailable`);
+          process.exit(1);
+        }
+
+        logger.success(
+          `Note reverted to v${result.reverted_to} → new version v${result.new_version}`,
+        );
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed to revert: ${err.message}`);
+        process.exit(1);
+      }
+    });
 }