@xiaofandegeng/rmemo 0.0.3

package/src/cmd/hook.js

@@ -0,0 +1,108 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { resolveRoot } from "../lib/paths.js";
+import { ensureDir, fileExists, readText, writeText } from "../lib/io.js";
+
+const execFileAsync = promisify(execFile);
+
+const HOOK_MARKER = "rmemo pre-commit hook";
+
+async function gitTopLevel(root) {
+  const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], { cwd: root });
+  return stdout.trim();
+}
+
+function nowStamp() {
+  const d = new Date();
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  const hh = String(d.getHours()).padStart(2, "0");
+  const mm = String(d.getMinutes()).padStart(2, "0");
+  const ss = String(d.getSeconds()).padStart(2, "0");
+  return `${y}${m}${day}_${hh}${mm}${ss}`;
+}
+
+function renderPreCommit({ rmemoBinAbs }) {
+  // Prefer calling the exact rmemo entrypoint that installed the hook.
+  // This keeps behavior consistent even before rmemo is published to npm.
+  const q = (s) => `"${String(s).replace(/"/g, '\\"')}"`;
+
+  return `#!/usr/bin/env bash
+# ${HOOK_MARKER}
+set -euo pipefail
+
+repo_root="$(git rev-parse --show-toplevel)"
+
+${q(rmemoBinAbs)} --root "$repo_root" --staged check
+`;
+}
+
+async function installPreCommitHook({ repoRoot, rmemoBinAbs, force }) {
+  const hooksDir = path.join(repoRoot, ".git", "hooks");
+  await ensureDir(hooksDir);
+
+  const hookPath = path.join(hooksDir, "pre-commit");
+  const content = renderPreCommit({ rmemoBinAbs });
+
+  if (await fileExists(hookPath)) {
+    const existing = await readText(hookPath, 256_000);
+    const ours = existing.includes(HOOK_MARKER);
+    if (!force && !ours) {
+      process.stderr.write(
+        `Refusing to overwrite existing pre-commit hook: ${hookPath}\n` +
+          `Re-run with --force to overwrite (a backup will be created).\n`
+      );
+      process.exitCode = 2;
+      return;
+    }
+    if (force && !ours) {
+      const bak = `${hookPath}.bak.${nowStamp()}`;
+      await fs.copyFile(hookPath, bak);
+      process.stdout.write(`Backed up existing hook to: ${bak}\n`);
+    }
+  }
+
+  await writeText(hookPath, content);
+  await fs.chmod(hookPath, 0o755);
+  process.stdout.write(`Installed pre-commit hook: ${hookPath}\n`);
+}
+
+export async function cmdHook({ rest, flags }) {
+  const sub = rest[0];
+  if (!sub || sub === "help") {
+    process.stdout.write(
+      [
+        "Usage:",
+        "  rmemo hook install [--force]",
+        "",
+        "Notes:",
+        "- The hook runs `rmemo check` before commit.",
+        "- Run `rmemo init` in the target repo to create `.repo-memory/rules.json`."
+      ].join("\n") + "\n"
+    );
+    return;
+  }
+
+  if (sub !== "install") {
+    throw new Error(`Unknown subcommand: hook ${sub}`);
+  }
+
+  const root = resolveRoot(flags);
+  const force = !!flags.force;
+
+  let repoRoot;
+  try {
+    repoRoot = await gitTopLevel(root);
+  } catch {
+    process.stderr.write(`Not a git repo (or git not available) under: ${root}\n`);
+    process.exitCode = 2;
+    return;
+  }
+
+  // Absolute path to the rmemo entrypoint used to install this hook.
+  const rmemoBinAbs = path.resolve(process.argv[1]);
+  await installPreCommitHook({ repoRoot, rmemoBinAbs, force });
+}

package/src/cmd/init.js

@@ -0,0 +1,86 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { ensureDir, fileExists, writeJson, writeText } from "../lib/io.js";
+import { resolveRoot } from "../lib/paths.js";
+import { journalDir, manifestPath, indexPath, rulesJsonPath, rulesPath, todosPath } from "../lib/paths.js";
+import { scanRepo } from "../core/scan.js";
+import { generateContext } from "../core/context.js";
+import { contextPath, memDir } from "../lib/paths.js";
+
+const DEFAULT_RULES = `# Rules
+
+This file is intentionally short and strict.
+
+## Project Conventions
+- (Add your conventions here)
+
+## Structure
+- (Add module boundaries here)
+
+## AI Constraints
+- Do not invent files or APIs. Ask if unsure.
+- Follow existing patterns in this repo.
+`;
+
+const DEFAULT_TODOS = `# Todos
+
+## Next
+- (Write the next concrete step)
+
+## Blockers
+- (If any)
+`;
+
+const DEFAULT_RULES_JSON = {
+  schema: 1,
+  // These are repo-relative patterns.
+  // Patterns support glob like "src/**" or regex like "re:^src/.*\\.vue$".
+  requiredPaths: [],
+  forbiddenPaths: [
+    // Example: forbid committing secrets
+    ".env",
+    ".env.*"
+  ],
+  // Content scans are optional and disabled by default.
+  // Use this to prevent committing secrets (keys/tokens) by matching patterns in file contents.
+  // Example:
+  // forbiddenContent: [
+  //   { include: ["**/*"], exclude: ["**/*.png"], match: "BEGIN PRIVATE KEY", message: "Do not commit private keys." }
+  // ]
+  forbiddenContent: [],
+  namingRules: [
+    // Example:
+    // {
+    //   "include": ["src/pages/**"],
+    //   "exclude": ["src/pages/**/__tests__/**"],
+    //   "target": "basename",
+    //   "match": "^[a-z0-9-]+\\.vue$",
+    //   "message": "Vue page filenames should be kebab-case."
+    // }
+  ]
+};
+
+export async function cmdInit({ flags }) {
+  const root = resolveRoot(flags);
+
+  await ensureDir(memDir(root));
+  await ensureDir(journalDir(root));
+
+  if (!(await fileExists(rulesPath(root)))) await writeText(rulesPath(root), DEFAULT_RULES);
+  if (!(await fileExists(rulesJsonPath(root)))) await writeJson(rulesJsonPath(root), DEFAULT_RULES_JSON);
+  if (!(await fileExists(todosPath(root)))) await writeText(todosPath(root), DEFAULT_TODOS);
+
+  const preferGit = flags["no-git"] ? false : true;
+  const maxFiles = Number(flags["max-files"] || 4000);
+  const { manifest, index } = await scanRepo(root, { maxFiles, preferGit });
+
+  await writeJson(manifestPath(root), manifest);
+  await writeJson(indexPath(root), index);
+
+  const snipLines = Number(flags["snip-lines"] || 120);
+  const recentDays = Number(flags["recent-days"] || 7);
+  const ctx = await generateContext(root, { snipLines, recentDays });
+  await fs.writeFile(contextPath(root), ctx, "utf8");
+
+  process.stdout.write(`Initialized: ${path.relative(process.cwd(), memDir(root))}\n`);
+}

package/src/cmd/log.js

@@ -0,0 +1,12 @@
+import path from "node:path";
+import { resolveRoot } from "../lib/paths.js";
+import { appendJournalEntry } from "../core/journal.js";
+
+export async function cmdLog({ rest, flags }) {
+  const root = resolveRoot(flags);
+  const text = rest.join(" ").trim();
+  if (!text) throw new Error("Missing log text. Usage: rmemo log <text>");
+
+  const p = await appendJournalEntry(root, { kind: "Log", text });
+  process.stdout.write(`Logged: ${path.relative(process.cwd(), p)}\n`);
+}

package/src/cmd/print.js

@@ -0,0 +1,15 @@
+import fs from "node:fs/promises";
+import { resolveRoot } from "../lib/paths.js";
+import { contextPath } from "../lib/paths.js";
+import { ensureContextFile } from "../core/context.js";
+
+export async function cmdPrint({ flags }) {
+  const root = resolveRoot(flags);
+  await ensureContextFile(root, {
+    snipLines: Number(flags["snip-lines"] || 120),
+    recentDays: Number(flags["recent-days"] || 7)
+  });
+  const s = await fs.readFile(contextPath(root), "utf8");
+  process.stdout.write(s);
+}
+

package/src/cmd/scan.js

@@ -0,0 +1,25 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { writeJson } from "../lib/io.js";
+import { resolveRoot } from "../lib/paths.js";
+import { indexPath, manifestPath, contextPath } from "../lib/paths.js";
+import { scanRepo } from "../core/scan.js";
+import { generateContext } from "../core/context.js";
+
+export async function cmdScan({ flags }) {
+  const root = resolveRoot(flags);
+  const preferGit = flags["no-git"] ? false : true;
+  const maxFiles = Number(flags["max-files"] || 4000);
+  const { manifest, index } = await scanRepo(root, { maxFiles, preferGit });
+
+  await writeJson(manifestPath(root), manifest);
+  await writeJson(indexPath(root), index);
+
+  const snipLines = Number(flags["snip-lines"] || 120);
+  const recentDays = Number(flags["recent-days"] || 7);
+  const ctx = await generateContext(root, { snipLines, recentDays });
+  await fs.writeFile(contextPath(root), ctx, "utf8");
+
+  process.stdout.write(`Scanned: ${path.relative(process.cwd(), root)}\n`);
+}
+

package/src/cmd/start.js

@@ -0,0 +1,41 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { resolveRoot } from "../lib/paths.js";
+import { manifestPath, indexPath, contextPath } from "../lib/paths.js";
+import { writeJson } from "../lib/io.js";
+import { scanRepo } from "../core/scan.js";
+import { generateContext } from "../core/context.js";
+import { cmdStatus } from "./status.js";
+
+export async function cmdStart({ flags }) {
+  const root = resolveRoot(flags);
+  const preferGit = flags["no-git"] ? false : true;
+  const maxFiles = Number(flags["max-files"] || 4000);
+
+  // 1) Scan and persist
+  const { manifest, index } = await scanRepo(root, { maxFiles, preferGit });
+  await writeJson(manifestPath(root), manifest);
+  await writeJson(indexPath(root), index);
+
+  // 2) Generate context pack
+  const snipLines = Number(flags["snip-lines"] || 120);
+  const recentDays = Number(flags["recent-days"] || 7);
+  const ctx = await generateContext(root, { snipLines, recentDays });
+  await fs.writeFile(contextPath(root), ctx, "utf8");
+
+  // 3) Print status (md) to stdout (paste-ready)
+  process.stdout.write("\n");
+  await cmdStatus({ flags: { ...flags, format: "md", mode: flags.mode || "brief" } });
+
+  const ctxRel = path.relative(process.cwd(), contextPath(root));
+  process.stdout.write(
+    [
+      "",
+      "## Paste To AI (Start Of Day)",
+      "",
+      `1. Paste file: ${ctxRel}`,
+      "2. If needed, also paste the Status above",
+      ""
+    ].join("\n")
+  );
+}

package/src/cmd/status.js

@@ -0,0 +1,147 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileExists, readText } from "../lib/io.js";
+import { resolveRoot } from "../lib/paths.js";
+import { journalDir, manifestPath, rulesPath, todosPath } from "../lib/paths.js";
+import { parseTodos } from "../core/todos.js";
+
+function clampLines(s, maxLines) {
+  const lines = s.split("\n");
+  if (lines.length <= maxLines) return s.trimEnd();
+  return lines.slice(0, maxLines).join("\n").trimEnd() + "\n[...truncated]";
+}
+
+async function readMaybe(p, maxBytes = 512_000) {
+  try {
+    if (!(await fileExists(p))) return null;
+    return await readText(p, maxBytes);
+  } catch {
+    return null;
+  }
+}
+
+async function listRecentJournalFiles(root, recentDays) {
+  const dir = journalDir(root);
+  try {
+    const ents = await fs.readdir(dir, { withFileTypes: true });
+    const files = ents
+      .filter((e) => e.isFile() && e.name.endsWith(".md"))
+      .map((e) => e.name)
+      .sort()
+      .reverse();
+    return files.slice(0, Math.max(0, recentDays));
+  } catch {
+    return [];
+  }
+}
+
+export async function cmdStatus({ flags }) {
+  const root = resolveRoot(flags);
+  const format = String(flags.format || "md").toLowerCase();
+  const mode = String(flags.mode || "full").toLowerCase();
+  const snipLines = Number(flags["snip-lines"] || 120);
+  const recentDays = Number(flags["recent-days"] || 7);
+
+  const rules = await readMaybe(rulesPath(root), 512_000);
+  const todosMd = await readMaybe(todosPath(root), 512_000);
+  const manifestText = await readMaybe(manifestPath(root), 2_000_000);
+
+  if (!rules && !todosMd && !manifestText) {
+    process.stderr.write(`No .repo-memory found under: ${root}\nRun: rmemo --root <repo> init\n`);
+    process.exitCode = 2;
+    return;
+  }
+
+  let manifest = null;
+  if (manifestText) {
+    try {
+      manifest = JSON.parse(manifestText);
+    } catch {
+      manifest = { parseError: true };
+    }
+  }
+
+  const todos = todosMd ? parseTodos(todosMd) : null;
+  const journalFiles = await listRecentJournalFiles(root, recentDays);
+  const journal = [];
+  for (const fn of journalFiles) {
+    const jp = path.join(journalDir(root), fn);
+    const s = await readMaybe(jp, 512_000);
+    if (!s) continue;
+    journal.push({ file: fn, text: s.trimEnd() });
+  }
+
+  if (format === "json") {
+    const payload = {
+      schema: 1,
+      generatedAt: new Date().toISOString(),
+      root,
+      mode,
+      title: manifest?.title || null,
+      manifest,
+      rules: rules ? clampLines(rules, snipLines) : null,
+      todos,
+      recentJournal: journal.map((j) => ({ file: j.file, text: clampLines(j.text, snipLines) }))
+    };
+    process.stdout.write(JSON.stringify(payload, null, 2) + "\n");
+    return;
+  }
+
+  if (format !== "md") {
+    throw new Error(`Unsupported --format: ${format} (use md or json)`);
+  }
+
+  const parts = [];
+  parts.push(`# Status\n`);
+  if (manifest?.title) parts.push(`Repo: ${manifest.title}\n`);
+  parts.push(`Root: ${root}\n`);
+  parts.push(`Generated: ${new Date().toISOString()}\n`);
+
+  if (todos) {
+    parts.push(`## Next\n`);
+    if (todos.next.length) parts.push(todos.next.map((x) => `- ${x}`).join("\n") + "\n");
+    else parts.push(`- (empty)\n`);
+
+    parts.push(`## Blockers\n`);
+    if (todos.blockers.length) parts.push(todos.blockers.map((x) => `- ${x}`).join("\n") + "\n");
+    else parts.push(`- (none)\n`);
+  }
+
+  if (manifest) {
+    parts.push(`## Structure Hints\n`);
+    if (Array.isArray(manifest.repoHints) && manifest.repoHints.length) parts.push(`- repoHints: ${manifest.repoHints.join(", ")}\n`);
+    if (Array.isArray(manifest.lockfiles) && manifest.lockfiles.length) parts.push(`- lockfiles: ${manifest.lockfiles.join(", ")}\n`);
+    if (manifest.packageJson?.frameworks?.length) parts.push(`- frameworks: ${manifest.packageJson.frameworks.join(", ")}\n`);
+    if (manifest.packageJson?.packageManager) parts.push(`- packageManager: ${manifest.packageJson.packageManager}\n`);
+    if (Array.isArray(manifest.topDirs) && manifest.topDirs.length) {
+      const dirs = manifest.topDirs.slice(0, 10).map((d) => `${d.name}(${d.fileCount})`).join(", ");
+      parts.push(`- topDirs: ${dirs}\n`);
+    }
+  }
+
+  if (mode !== "brief") {
+    if (rules) {
+      parts.push(`## Rules (Excerpt)\n`);
+      parts.push(clampLines(rules, Math.min(snipLines, 80)) + "\n");
+    }
+
+    if (journal.length) {
+      parts.push(`## Recent Journal\n`);
+      for (const j of journal) {
+        parts.push(`### ${j.file}\n`);
+        parts.push(clampLines(j.text, Math.min(snipLines, 120)) + "\n");
+      }
+    }
+  }
+
+  parts.push(`## Paste To AI\n`);
+  parts.push(
+    [
+      "1. Run: `rmemo context`",
+      "2. Paste: `.repo-memory/context.md`",
+      "3. Optionally paste this `status` output for a quick 'where we are now'."
+    ].join("\n") + "\n"
+  );
+
+  process.stdout.write(parts.join("\n").trimEnd() + "\n");
+}

package/src/cmd/todo.js

@@ -0,0 +1,85 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import { resolveRoot } from "../lib/paths.js";
+import {
+  ensureTodosFile,
+  parseTodos,
+  addTodoNext,
+  addTodoBlocker,
+  removeTodoNextByIndex,
+  removeTodoBlockerByIndex
+} from "../core/todos.js";
+import { todosPath } from "../lib/paths.js";
+
+export async function cmdTodo({ rest, flags }) {
+  const root = resolveRoot(flags);
+  const sub = rest[0];
+
+  if (!sub || sub === "help") {
+    process.stdout.write(
+      [
+        "Usage:",
+        "  rmemo todo add <text>",
+        "  rmemo todo block <text>",
+        "  rmemo todo done <n>",
+        "  rmemo todo unblock <n>",
+        "  rmemo todo ls",
+        ""
+      ].join("\n") + "\n"
+    );
+    return;
+  }
+
+  if (sub === "add") {
+    const text = rest.slice(1).join(" ").trim();
+    if (!text) throw new Error("Missing text. Usage: rmemo todo add <text>");
+    const p = await addTodoNext(root, text);
+    process.stdout.write(`Updated todos: ${path.relative(process.cwd(), p)}\n`);
+    return;
+  }
+
+  if (sub === "block") {
+    const text = rest.slice(1).join(" ").trim();
+    if (!text) throw new Error("Missing text. Usage: rmemo todo block <text>");
+    const p = await addTodoBlocker(root, text);
+    process.stdout.write(`Updated todos: ${path.relative(process.cwd(), p)}\n`);
+    return;
+  }
+
+  if (sub === "ls") {
+    await ensureTodosFile(root);
+    const md = await fs.readFile(todosPath(root), "utf8");
+    const t = parseTodos(md);
+    const numbered = (arr) => arr.map((x, i) => `${i + 1}. ${x}`);
+    const out = [
+      "# Todos",
+      "",
+      "## Next",
+      ...(t.next.length ? numbered(t.next) : ["- (empty)"]),
+      "",
+      "## Blockers",
+      ...(t.blockers.length ? numbered(t.blockers) : ["- (none)"]),
+      ""
+    ].join("\n");
+    process.stdout.write(out);
+    return;
+  }
+
+  if (sub === "done") {
+    const n = rest[1];
+    if (!n) throw new Error("Missing index. Usage: rmemo todo done <n>");
+    const p = await removeTodoNextByIndex(root, n);
+    process.stdout.write(`Updated todos: ${path.relative(process.cwd(), p)}\n`);
+    return;
+  }
+
+  if (sub === "unblock") {
+    const n = rest[1];
+    if (!n) throw new Error("Missing index. Usage: rmemo todo unblock <n>");
+    const p = await removeTodoBlockerByIndex(root, n);
+    process.stdout.write(`Updated todos: ${path.relative(process.cwd(), p)}\n`);
+    return;
+  }
+
+  throw new Error(`Unknown subcommand: todo ${sub}`);
+}