@xiaofandegeng/rmemo 0.0.3

package/src/core/scan.js

@@ -0,0 +1,282 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { hasGit, isGitRepo, listGitFiles } from "../lib/git.js";
+import { walkFiles } from "../lib/walk.js";
+import { readText } from "../lib/io.js";
+
+function extOf(p) {
+  const base = path.posix.basename(p);
+  if (base.startsWith(".") && !base.includes(".")) return base; // ".env" style
+  const idx = base.lastIndexOf(".");
+  return idx === -1 ? "" : base.slice(idx + 1).toLowerCase();
+}
+
+function detectFromPackageJson(pkg) {
+  const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+  const depNames = new Set(Object.keys(deps));
+
+  const frameworks = [];
+  if (depNames.has("vue")) frameworks.push("vue");
+  if (depNames.has("react")) frameworks.push("react");
+  if (depNames.has("next")) frameworks.push("nextjs");
+  if (depNames.has("nuxt")) frameworks.push("nuxt");
+  if (depNames.has("uni-app") || depNames.has("@dcloudio/uni-app")) frameworks.push("uni-app");
+  if (depNames.has("@tarojs/taro")) frameworks.push("taro");
+  if (depNames.has("vite")) frameworks.push("vite");
+
+  const pkgManager = pkg.packageManager || null;
+  const workspaces = pkg.workspaces || null;
+
+  return { frameworks, pkgManager, workspaces, scripts: pkg.scripts || {} };
+}
+
+function detectMonorepoSignals(files) {
+  const set = new Set(files);
+  const signals = [];
+  if (set.has("pnpm-workspace.yaml")) signals.push("pnpm-workspace");
+  if (set.has("lerna.json")) signals.push("lerna");
+  if (set.has("turbo.json")) signals.push("turborepo");
+  if (set.has("nx.json")) signals.push("nx");
+  if (set.has("rush.json")) signals.push("rush");
+  if (set.has("workspace.json")) signals.push("workspace.json");
+  return signals;
+}
+
+function detectDocsRoots(files) {
+  const roots = new Set();
+  for (const f of files) {
+    if (f.startsWith("docs/")) roots.add("docs");
+    if (f.startsWith("doc/")) roots.add("doc");
+    if (f.startsWith("documentation/")) roots.add("documentation");
+  }
+  return Array.from(roots).sort();
+}
+
+function detectApiContracts(files) {
+  const out = [];
+  for (const f of files) {
+    const base = path.posix.basename(f).toLowerCase();
+    if (base === "openapi.yaml" || base === "openapi.yml" || base === "swagger.yaml" || base === "swagger.yml") out.push(f);
+    if (base === "openapi.json" || base === "swagger.json") out.push(f);
+  }
+  return Array.from(new Set(out)).slice(0, 30);
+}
+
+function detectSubprojectCandidates(files) {
+  // Heuristic: subproject roots are dirs containing common manifest/config files.
+  // Keep it generic and cheap: only look at shallow depths.
+  const candidates = new Map(); // dir -> { reasons: Set<string>, files: Set<string> }
+  const add = (dir, reason, file) => {
+    if (!dir || dir === ".") return;
+    const cur = candidates.get(dir) || { reasons: new Set(), files: new Set() };
+    cur.reasons.add(reason);
+    if (file) cur.files.add(file);
+    candidates.set(dir, cur);
+  };
+
+  for (const f of files) {
+    const parts = f.split("/");
+    if (parts.length < 2) continue;
+    const dir = parts.slice(0, -1).join("/");
+    const base = parts[parts.length - 1];
+
+    // Depth cap: avoid too deep noise
+    if (parts.length > 4) continue;
+
+    if (base === "package.json") add(dir, "package.json", f);
+    if (base === "pom.xml") add(dir, "pom.xml", f);
+    if (base === "go.mod") add(dir, "go.mod", f);
+    if (base === "Cargo.toml") add(dir, "Cargo.toml", f);
+    if (base === "composer.json") add(dir, "composer.json", f);
+    if (base === "pyproject.toml" || base === "requirements.txt") add(dir, "python", f);
+
+    // Miniapp-ish hints (generic, not tied to one vendor)
+    if (base === "project.config.json") add(dir, "miniapp:project.config.json", f);
+    if (base === "app.json" && dir.includes("mini")) add(dir, "miniapp:app.json", f);
+  }
+
+  // Prefer top-level-ish subprojects: unique dirs not nested inside another candidate.
+  const dirs = Array.from(candidates.keys()).sort((a, b) => a.length - b.length);
+  const filtered = [];
+  for (const d of dirs) {
+    if (filtered.some((x) => d.startsWith(x + "/"))) continue;
+    filtered.push(d);
+  }
+
+  return filtered.slice(0, 30).map((dir) => {
+    const meta = candidates.get(dir);
+    return {
+      dir,
+      reasons: Array.from(meta.reasons).sort(),
+      hintFiles: Array.from(meta.files).sort().slice(0, 10)
+    };
+  });
+}
+
+async function safeJson(absPath) {
+  try {
+    const s = await readText(absPath);
+    return JSON.parse(s);
+  } catch {
+    return null;
+  }
+}
+
+function pickTopLevelDirs(files) {
+  const counts = new Map();
+  for (const f of files) {
+    const parts = f.split("/");
+    const top = parts[0] || "";
+    if (!top || top.startsWith(".")) continue;
+    counts.set(top, (counts.get(top) || 0) + 1);
+  }
+  return [...counts.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 20)
+    .map(([name, fileCount]) => ({ name, fileCount }));
+}
+
+function detectRepoType(files) {
+  const set = new Set(files);
+  const hints = [];
+  if (set.has("pom.xml") || [...set].some((p) => p.endsWith("build.gradle") || p.endsWith("build.gradle.kts"))) hints.push("jvm");
+  if (set.has("go.mod")) hints.push("go");
+  if (set.has("package.json")) hints.push("node");
+  if (set.has("Cargo.toml")) hints.push("rust");
+  if (set.has("composer.json")) hints.push("php");
+  if (set.has("requirements.txt") || set.has("pyproject.toml")) hints.push("python");
+  return hints;
+}
+
+function detectLockfiles(files) {
+  const set = new Set(files);
+  const locks = [];
+  if (set.has("pnpm-lock.yaml")) locks.push("pnpm-lock.yaml");
+  if (set.has("package-lock.json")) locks.push("package-lock.json");
+  if (set.has("yarn.lock")) locks.push("yarn.lock");
+  if (set.has("bun.lockb")) locks.push("bun.lockb");
+  return locks;
+}
+
+function pickKeyFiles(files) {
+  const wanted = [
+    "README.md",
+    "README.zh-CN.md",
+    "README.zh.md",
+    "CONTRIBUTING.md",
+    "LICENSE",
+    "openapi.yaml",
+    "openapi.yml",
+    "swagger.yaml",
+    "swagger.yml",
+    "docker-compose.yml",
+    "docker-compose.yaml",
+    ".env.example",
+    ".env.sample"
+  ];
+  const set = new Set(files);
+  const hits = wanted.filter((p) => set.has(p));
+
+  // plus: .github workflows
+  for (const f of files) {
+    if (f.startsWith(".github/workflows/") && (f.endsWith(".yml") || f.endsWith(".yaml"))) hits.push(f);
+  }
+  return Array.from(new Set(hits)).slice(0, 50);
+}
+
+function summarizeExtensions(files) {
+  const counts = new Map();
+  for (const f of files) {
+    const ext = extOf(f);
+    if (!ext) continue;
+    counts.set(ext, (counts.get(ext) || 0) + 1);
+  }
+  return [...counts.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 20)
+    .map(([ext, count]) => ({ ext, count }));
+}
+
+export async function scanRepo(root, { maxFiles = 4000, preferGit = true } = {}) {
+  let files = [];
+  const gitOk = preferGit && (await hasGit()) && (await isGitRepo(root));
+
+  if (gitOk) {
+    files = await listGitFiles(root);
+  } else {
+    files = await walkFiles(root, { maxFiles });
+  }
+
+  if (files.length > maxFiles) files = files.slice(0, maxFiles);
+
+  const repoHints = detectRepoType(files);
+  const monorepoSignals = detectMonorepoSignals(files);
+  const lockfiles = detectLockfiles(files);
+  const keyFiles = pickKeyFiles(files);
+  const docsRoots = detectDocsRoots(files);
+  const apiContracts = detectApiContracts(files);
+  const subprojects = detectSubprojectCandidates(files);
+  const topDirs = pickTopLevelDirs(files);
+  const topExts = summarizeExtensions(files);
+
+  const pkgAbs = path.join(root, "package.json");
+  const pkg = await safeJson(pkgAbs);
+  const pkgInfo = pkg ? detectFromPackageJson(pkg) : null;
+  const monorepo = {
+    signals: monorepoSignals,
+    rootWorkspaces: pkgInfo?.workspaces || null
+  };
+
+  const manifest = {
+    schema: 1,
+    generatedAt: new Date().toISOString(),
+    root,
+    usingGit: gitOk,
+    fileCount: files.length,
+    repoHints,
+    monorepo,
+    lockfiles,
+    topDirs,
+    topExts,
+    keyFiles,
+    docsRoots,
+    apiContracts,
+    subprojects,
+    packageJson: pkg
+      ? {
+          name: pkg.name || null,
+          private: !!pkg.private,
+          scripts: pkgInfo?.scripts || {},
+          frameworks: pkgInfo?.frameworks || [],
+          packageManager: pkgInfo?.pkgManager || null,
+          workspaces: pkgInfo?.workspaces || null
+        }
+      : null
+  };
+
+  // Index is for fast context generation without re-walking every time.
+  const index = {
+    schema: 1,
+    generatedAt: new Date().toISOString(),
+    files
+  };
+
+  // Rough repo title
+  let title = null;
+  if (pkg?.name) title = pkg.name;
+  if (!title) title = path.basename(root);
+  manifest.title = title;
+
+  // Try read repo README short summary
+  const readme = keyFiles.find((p) => /^README(\..+)?\.md$/i.test(p));
+  if (readme) {
+    try {
+      const s = await readText(path.join(root, readme), 64_000);
+      manifest.readmeHead = s.split("\n").slice(0, 40).join("\n");
+    } catch {
+      // ignore
+    }
+  }
+
+  return { manifest, index };
+}

package/src/core/todos.js

@@ -0,0 +1,143 @@
+import fs from "node:fs/promises";
+import { ensureDir, fileExists, writeText } from "../lib/io.js";
+import { memDir, todosPath } from "../lib/paths.js";
+
+const DEFAULT_TODOS = `# Todos
+
+## Next
+- (Write the next concrete step)
+
+## Blockers
+- (If any)
+`;
+
+export function parseTodos(md) {
+  const out = { next: [], blockers: [], raw: String(md || "").trimEnd() };
+  const lines = String(md || "").split("\n");
+  let section = null;
+  for (const line of lines) {
+    const h = line.match(/^##\s+(.*)\s*$/);
+    if (h) {
+      const t = h[1].toLowerCase();
+      if (t.startsWith("next")) section = "next";
+      else if (t.startsWith("block")) section = "blockers";
+      else section = null;
+      continue;
+    }
+    const m = line.match(/^\s*-\s+(.*)\s*$/);
+    if (m && section) out[section].push(m[1]);
+  }
+  return out;
+}
+
+function ensureSection(md, title) {
+  const has = new RegExp(`^##\\s+${title}\\s*$`, "im").test(md);
+  if (has) return md;
+  const trimmed = md.trimEnd();
+  if (!trimmed) return `## ${title}\n`;
+  return trimmed + `\n\n## ${title}\n`;
+}
+
+function findSectionRange(lines, title) {
+  const headerRe = new RegExp(`^##\\s+${title}\\s*$`, "i");
+  const start = lines.findIndex((l) => headerRe.test(l.trim()));
+  if (start === -1) return null;
+  let end = start + 1;
+  while (end < lines.length && !/^##\s+/.test(lines[end])) end++;
+  return { start, end };
+}
+
+function insertBulletIntoSection(md, title, bulletText) {
+  let s = String(md || "");
+  s = ensureSection(s, title);
+  const lines = s.split("\n");
+  const headerRe = new RegExp(`^##\\s+${title}\\s*$`, "i");
+  const idx = lines.findIndex((l) => headerRe.test(l.trim()));
+  if (idx === -1) return s.trimEnd() + `\n- ${bulletText}\n`;
+
+  // Drop default template placeholder bullets once real items are being added.
+  const range = findSectionRange(lines, title);
+  if (range) {
+    const placeholder =
+      title.toLowerCase() === "next"
+        ? /^\s*-\s+\(Write the next concrete step\)\s*$/
+        : title.toLowerCase() === "blockers"
+          ? /^\s*-\s+\(If any\)\s*$/
+          : null;
+    if (placeholder) {
+      for (let i = range.start + 1; i < range.end; i++) {
+        if (placeholder.test(lines[i])) {
+          lines.splice(i, 1);
+          break;
+        }
+      }
+    }
+  }
+
+  // Insert after header + blank lines, but before next section header.
+  let insertAt = idx + 1;
+  while (insertAt < lines.length && lines[insertAt].trim() === "") insertAt++;
+  while (insertAt < lines.length && !/^##\s+/.test(lines[insertAt])) insertAt++;
+
+  lines.splice(insertAt, 0, `- ${bulletText}`);
+  return lines.join("\n").trimEnd() + "\n";
+}
+
+function removeNthBulletFromSection(md, title, n1) {
+  const n = Number(n1);
+  if (!Number.isInteger(n) || n <= 0) throw new Error(`Index must be a positive integer (got: ${n1})`);
+
+  const lines = String(md || "").split("\n");
+  const range = findSectionRange(lines, title);
+  if (!range) throw new Error(`Missing section: ## ${title}`);
+
+  const bulletIdxs = [];
+  for (let i = range.start + 1; i < range.end; i++) {
+    if (/^\s*-\s+/.test(lines[i])) bulletIdxs.push(i);
+  }
+  if (n > bulletIdxs.length) throw new Error(`No such item: ${title} #${n} (total: ${bulletIdxs.length})`);
+
+  const rmAt = bulletIdxs[n - 1];
+  lines.splice(rmAt, 1);
+  return lines.join("\n").trimEnd() + "\n";
+}
+
+export async function ensureTodosFile(root) {
+  await ensureDir(memDir(root));
+  const p = todosPath(root);
+  if (await fileExists(p)) return p;
+  await writeText(p, DEFAULT_TODOS);
+  return p;
+}
+
+export async function addTodoNext(root, text) {
+  const p = await ensureTodosFile(root);
+  const s = await fs.readFile(p, "utf8");
+  const updated = insertBulletIntoSection(s, "Next", text);
+  await fs.writeFile(p, updated, "utf8");
+  return p;
+}
+
+export async function addTodoBlocker(root, text) {
+  const p = await ensureTodosFile(root);
+  const s = await fs.readFile(p, "utf8");
+  const updated = insertBulletIntoSection(s, "Blockers", text);
+  await fs.writeFile(p, updated, "utf8");
+  return p;
+}
+
+export async function removeTodoNextByIndex(root, index1) {
+  const p = await ensureTodosFile(root);
+  const s = await fs.readFile(p, "utf8");
+  const updated = removeNthBulletFromSection(s, "Next", index1);
+  await fs.writeFile(p, updated, "utf8");
+  return p;
+}
+
+export async function removeTodoBlockerByIndex(root, index1) {
+  const p = await ensureTodosFile(root);
+  const s = await fs.readFile(p, "utf8");
+  const updated = removeNthBulletFromSection(s, "Blockers", index1);
+  await fs.writeFile(p, updated, "utf8");
+  return p;
+}

package/src/lib/args.js

@@ -0,0 +1,81 @@
+export function parseArgs(argv) {
+  const flags = {};
+  const rest = [];
+
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (!a) continue;
+    if (a === "--") {
+      rest.push(...argv.slice(i + 1));
+      break;
+    }
+    if (a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      if (eq !== -1) {
+        flags[a.slice(2, eq)] = a.slice(eq + 1);
+      } else {
+        const k = a.slice(2);
+        // Common boolean flag convention: `--no-foo` means a boolean toggle.
+        // Do not accidentally consume the next positional arg as its value.
+        if (k.startsWith("no-") || k === "help" || k === "force" || k === "staged") {
+          flags[k] = true;
+          continue;
+        }
+        const next = argv[i + 1];
+        if (next && !next.startsWith("-")) {
+          flags[k] = next;
+          i++;
+        } else {
+          flags[k] = true;
+        }
+      }
+      continue;
+    }
+    if (a.startsWith("-") && a.length > 1) {
+      const k = a.slice(1);
+      flags[k] = true;
+      continue;
+    }
+    rest.push(a);
+  }
+
+  const cmd = rest.shift();
+  return { cmd, rest, flags };
+}
+
+export function printHelp() {
+  const help = `
+rmemo - repo memory + dev journal CLI
+
+Usage:
+  rmemo init                 Initialize .repo-memory/ and run a scan
+  rmemo scan                 Scan repo and update manifest/index
+  rmemo log <text>           Append a note to today's journal
+  rmemo status               Print a paste-ready status summary (rules/todos/journal)
+  rmemo check                Enforce .repo-memory/rules.json (for CI / hooks)
+  rmemo hook install         Install a git pre-commit hook that runs \`rmemo check\`
+  rmemo start                Scan + generate context + print status (daily entrypoint)
+  rmemo done                 Append end-of-day notes to journal (supports stdin) and optionally update todos
+  rmemo todo add <text>      Add a todo item under "## Next"
+  rmemo todo block <text>    Add a blocker under "## Blockers"
+  rmemo todo done <n>        Remove the nth item from "## Next"
+  rmemo todo unblock <n>     Remove the nth item from "## Blockers"
+  rmemo todo ls              Print parsed todos (Next/Blockers)
+  rmemo context              Generate .repo-memory/context.md
+  rmemo print                Print context.md to stdout (generate first if missing)
+
+Options:
+  --root <path>              Repo root (default: cwd)
+  --format <md|json>         Output format for status (default: md)
+  --mode <brief|full>        Output detail level for status/start (default: full)
+  --next <text>              Append a bullet to .repo-memory/todos.md under "## Next"
+  --blocker <text>           Append a bullet to .repo-memory/todos.md under "## Blockers"
+  --staged                   For check: only validate staged (git index) files
+  --force                    Overwrite existing git hook (creates backup)
+  --max-files <n>            Max files to analyze (default: 4000)
+  --snip-lines <n>           Max lines per snippet (default: 120)
+  --recent-days <n>          Include recent journal entries (default: 7)
+  --no-git                   Don't use git for scanning (fallback to filesystem walk)
+`;
+  process.stdout.write(help.trimStart());
+}

package/src/lib/git.js

@@ -0,0 +1,35 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+export async function hasGit() {
+  try {
+    await execFileAsync("git", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function isGitRepo(root) {
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--is-inside-work-tree"], { cwd: root });
+    return stdout.trim() === "true";
+  } catch {
+    return false;
+  }
+}
+
+export async function listGitFiles(root) {
+  const tracked = await execFileAsync("git", ["ls-files", "-z"], { cwd: root, maxBuffer: 1024 * 1024 * 50 });
+  const untracked = await execFileAsync("git", ["ls-files", "--others", "--exclude-standard", "-z"], {
+    cwd: root,
+    maxBuffer: 1024 * 1024 * 50
+  });
+
+  const out = (tracked.stdout + untracked.stdout).split("\0").filter(Boolean);
+  // Normalize to posix-like relative paths (git always returns / separators).
+  return Array.from(new Set(out)).sort();
+}
+

package/src/lib/io.js

@@ -0,0 +1,43 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+export async function ensureDir(p) {
+  await fs.mkdir(p, { recursive: true });
+}
+
+export async function fileExists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function readText(p, maxBytes = 2_000_000) {
+  const buf = await fs.readFile(p);
+  if (buf.byteLength > maxBytes) {
+    return buf.subarray(0, maxBytes).toString("utf8") + "\n[...truncated]";
+  }
+  return buf.toString("utf8");
+}
+
+export async function writeText(p, s) {
+  await ensureDir(path.dirname(p));
+  await fs.writeFile(p, s, "utf8");
+}
+
+export async function writeJson(p, obj) {
+  await writeText(p, JSON.stringify(obj, null, 2) + "\n");
+}
+
+export async function readJson(p) {
+  const s = await readText(p);
+  return JSON.parse(s);
+}
+
+export function exitWithError(msg) {
+  process.stderr.write(String(msg).trimEnd() + "\n");
+  process.exitCode = 1;
+}
+

package/src/lib/paths.js

@@ -0,0 +1,38 @@
+import path from "node:path";
+
+export function resolveRoot(flags) {
+  const root = flags?.root ? String(flags.root) : process.cwd();
+  return path.resolve(root);
+}
+
+export function memDir(root) {
+  return path.join(root, ".repo-memory");
+}
+
+export function journalDir(root) {
+  return path.join(memDir(root), "journal");
+}
+
+export function manifestPath(root) {
+  return path.join(memDir(root), "manifest.json");
+}
+
+export function indexPath(root) {
+  return path.join(memDir(root), "index.json");
+}
+
+export function rulesPath(root) {
+  return path.join(memDir(root), "rules.md");
+}
+
+export function rulesJsonPath(root) {
+  return path.join(memDir(root), "rules.json");
+}
+
+export function contextPath(root) {
+  return path.join(memDir(root), "context.md");
+}
+
+export function todosPath(root) {
+  return path.join(memDir(root), "todos.md");
+}

package/src/lib/stdin.js

@@ -0,0 +1,12 @@
+export async function readStdinText() {
+  // If nothing is piped, stdin is usually a TTY. Do not block waiting for EOF.
+  if (process.stdin.isTTY) return "";
+  return await new Promise((resolve, reject) => {
+    let s = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => (s += chunk));
+    process.stdin.on("end", () => resolve(s));
+    process.stdin.on("error", reject);
+    process.stdin.resume();
+  });
+}

package/src/lib/time.js

@@ -0,0 +1,13 @@
+export function todayYmd(d = new Date()) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+
+export function nowHm(d = new Date()) {
+  const h = String(d.getHours()).padStart(2, "0");
+  const m = String(d.getMinutes()).padStart(2, "0");
+  return `${h}:${m}`;
+}
+

package/src/lib/walk.js

@@ -0,0 +1,44 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const DEFAULT_IGNORES = new Set([
+  ".git",
+  ".repo-memory",
+  "node_modules",
+  "dist",
+  "build",
+  "out",
+  "coverage",
+  ".next",
+  ".nuxt",
+  ".turbo",
+  ".vite",
+  ".idea",
+  ".vscode"
+]);
+
+export async function walkFiles(root, { maxFiles = 4000 } = {}) {
+  const result = [];
+
+  async function walkDir(rel) {
+    const abs = path.join(root, rel);
+    const entries = await fs.readdir(abs, { withFileTypes: true });
+    for (const ent of entries) {
+      const name = ent.name;
+      if (DEFAULT_IGNORES.has(name)) continue;
+      const relPath = rel ? path.posix.join(rel, name) : name;
+      const absPath = path.join(root, relPath);
+      if (ent.isDirectory()) {
+        await walkDir(relPath);
+      } else if (ent.isFile()) {
+        result.push(relPath);
+        if (result.length >= maxFiles) return;
+      }
+      if (result.length >= maxFiles) return;
+    }
+  }
+
+  await walkDir("");
+  return result.sort();
+}
+