@flarecode/import-memory 0.2.1 → 0.2.3

package/README.md

@@ -1,20 +1,23 @@
 # @flarecode/import-memory
 
-One-command helper for finding local AI coding-agent history before importing it into FlareCode.
+One-command helper for importing your local AI coding-agent preferences into FlareCode.
 
 ```sh
 npx --yes @flarecode/import-memory@latest
 ```
 
-The helper scans common local locations for Claude Code, Codex, Cursor, VS Code, and repo-local instruction files. Raw transcript contents are not uploaded by this package. The shell wrapper at `https://flarecode.sh/import.sh` only detects a package runner and delegates to this npm package.
+Run it from **anywhere**. It reads your global config (e.g. `~/.claude/CLAUDE.md`) and discovers rule files — `AGENTS.md`, `CLAUDE.md`, `.cursorrules`, `.cursor/rules`, `.github/copilot-instructions.md` — across all your repos (common code folders, your Cursor/VS Code workspaces, and the current directory), plus a redacted summary of your Claude Code, Codex, Cursor, and VS Code settings.
+
+Rule files are redacted and deduplicated on your machine before upload. Raw transcript contents are never uploaded. The shell wrapper at `https://flarecode.sh/import.sh` only detects a package runner and delegates to this npm package.
 
 Useful flags:
 
 ```sh
 npx --yes @flarecode/import-memory@latest --dry-run
 npx --yes @flarecode/import-memory@latest --json
-npx --yes @flarecode/import-memory@latest --source claude,codex,cursor
+npx --yes @flarecode/import-memory@latest --repos ~/code,~/work
 npx --yes @flarecode/import-memory@latest --repo ~/code/my-app
+npx --yes @flarecode/import-memory@latest --no-discover
+npx --yes @flarecode/import-memory@latest --source claude,codex,cursor
 npx --yes @flarecode/import-memory@latest --since 90d
-npx --yes @flarecode/import-memory@latest --no-transcripts
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flarecode/import-memory",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "One-command helper for discovering local coding-agent memory sources before importing them into FlareCode.",
   "type": "module",
   "license": "UNLICENSED",
@@ -11,10 +11,7 @@
   "exports": {
     ".": "./src/scanner.js"
   },
-  "files": [
-    "src",
-    "README.md"
-  ],
+  "files": ["src", "README.md"],
   "publishConfig": {
     "access": "public"
   },

package/src/index.js

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
 import { exec } from "node:child_process";
+import { readFileSync } from "node:fs";
 import process from "node:process";
 import { formatScanSummary, parseSince, parseSourceFilter, readRulesContent, scanSources } from "./scanner.js";
 
-const VERSION = "0.2.0";
+// Read from package.json (always shipped in the tarball) so --version never
+// drifts from the published version.
+const VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
 const API_BASE = "https://api.flarecode.sh";
 const APP_BASE = "https://app.flarecode.sh";
 
@@ -76,14 +79,18 @@ async function main(argv) {
 
   if (!args.json) {
     process.stdout.write("FlareCode memory import helper\n");
-    process.stdout.write("Scanning local coding-agent history and settings.\n");
-    process.stdout.write("Raw transcript contents stay on this machine in this version.\n\n");
+    process.stdout.write("Scanning your global config and rule files across every repo — run it from anywhere.\n");
+    process.stdout.write(
+      "Only rule files and a settings summary are uploaded (redacted). Transcript contents stay on this machine.\n\n",
+    );
   }
 
   const result = await scanSources({
     sources,
     sinceMs,
     repoPath: args.repo,
+    reposDirs: args.repos,
+    discover: !args.noDiscover,
     includeTranscripts: !args.noTranscripts,
   });
 
@@ -127,9 +134,11 @@ function parseArgs(argv) {
     help: false,
     version: false,
     noTranscripts: false,
+    noDiscover: false,
     source: null,
     since: null,
     repo: null,
+    repos: [],
   };
 
   for (let i = 0; i < argv.length; i += 1) {
@@ -140,18 +149,28 @@ function parseArgs(argv) {
     else if (arg === "--help" || arg === "-h") out.help = true;
     else if (arg === "--version" || arg === "-v") out.version = true;
     else if (arg === "--no-transcripts") out.noTranscripts = true;
+    else if (arg === "--no-discover") out.noDiscover = true;
     else if (arg === "--source") out.source = requireValue(argv, ++i, "--source");
     else if (arg.startsWith("--source=")) out.source = arg.slice("--source=".length);
     else if (arg === "--since") out.since = requireValue(argv, ++i, "--since");
     else if (arg.startsWith("--since=")) out.since = arg.slice("--since=".length);
     else if (arg === "--repo") out.repo = requireValue(argv, ++i, "--repo");
     else if (arg.startsWith("--repo=")) out.repo = arg.slice("--repo=".length);
+    else if (arg === "--repos") out.repos.push(...splitList(requireValue(argv, ++i, "--repos")));
+    else if (arg.startsWith("--repos=")) out.repos.push(...splitList(arg.slice("--repos=".length)));
     else throw new Error(`Unknown argument: ${arg}`);
   }
 
   return out;
 }
 
+function splitList(value) {
+  return value
+    .split(",")
+    .map((v) => v.trim())
+    .filter(Boolean);
+}
+
 function requireValue(argv, index, flag) {
   const value = argv[index];
   if (!value || value.startsWith("--")) throw new Error(`${flag} requires a value`);
@@ -164,14 +183,20 @@ function helpText() {
 Usage:
   npx --yes @flarecode/import-memory@latest [options]
 
+By default it reads your global config (e.g. ~/.claude/CLAUDE.md) and discovers
+rule files (AGENTS.md, CLAUDE.md, .cursorrules, Copilot instructions) across all
+your repos — so it works no matter which directory you run it from.
+
 Options:
   --dry-run              Scan and print a summary without preparing upload.
   --skip-upload          Scan and print a summary without uploading.
   --json                 Print machine-readable scan output.
   --source <list>        Comma-separated: claude,codex,cursor,vscode,repo.
   --since <duration>     Only include files modified within 30d, 12w, 6m, or 1y.
-  --repo <path>          Include repo-local rules from a specific repo.
-  --no-transcripts       Import rules/settings only.
+  --repo <path>          Also include rules from a specific repo.
+  --repos <dirs>         Comma-separated parent folders to discover repos under.
+  --no-discover          Only scan the current repo, not all discovered repos.
+  --no-transcripts       Skip even counting transcripts.
   --version, -v          Print version.
   --help, -h             Print this help.
 `;

package/src/scanner.js

@@ -4,11 +4,36 @@ import path from "node:path";
 
 const DEFAULT_MAX_DEPTH = 6;
 const DEFAULT_MAX_FILES_PER_SOURCE = 5000;
+const DEFAULT_MAX_REPOS = 200;
+const REPO_DISCOVERY_DEPTH = 3;
 
 const SOURCE_IDS = new Set(["claude", "codex", "cursor", "vscode", "repo"]);
 
 const TRANSCRIPT_EXTENSIONS = new Set([".jsonl", ".json", ".ndjson"]);
 
+// Conventional parent folders to look for the user's repos in, so a run from
+// anywhere (e.g. ~) still discovers rule files across every repo — not just the
+// cwd. Relative to home.
+const CODE_ROOTS = [
+  "code",
+  "Code",
+  "projects",
+  "Projects",
+  "src",
+  "dev",
+  "Developer",
+  "work",
+  "repos",
+  "git",
+  "github",
+  "GitHub",
+  "workspace",
+  "workspaces",
+  "conductor/workspaces",
+];
+
+const RULE_BASENAMES = new Set(["agents.md", "claude.md", ".cursorrules"]);
+
 export function parseSourceFilter(value) {
   if (!value) return [...SOURCE_IDS];
   const parsed = value
@@ -36,11 +61,16 @@ export async function scanSources(options = {}) {
   const sourceFilter = new Set(options.sources ?? [...SOURCE_IDS]);
   const home = options.home ?? homedir();
   const cwd = options.cwd ?? process.cwd();
-  const repoPath = options.repoPath ? expandHome(options.repoPath, home) : await findRepoRoot(cwd);
   const sinceMs = options.sinceMs ?? null;
   const includeTranscripts = options.includeTranscripts ?? true;
   const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
   const maxFilesPerSource = options.maxFilesPerSource ?? DEFAULT_MAX_FILES_PER_SOURCE;
+  const discover = options.discover ?? true;
+  const maxRepos = options.maxRepos ?? DEFAULT_MAX_REPOS;
+  const explicitRepos = (options.repoPaths ?? (options.repoPath ? [options.repoPath] : [])).map((p) =>
+    expandHome(p, home),
+  );
+  const reposDirs = (options.reposDirs ?? []).map((p) => expandHome(p, home));
 
   const sources = [];
 
@@ -100,12 +130,14 @@ export async function scanSources(options = {}) {
     );
   }
 
+  let repoPaths = [];
   if (sourceFilter.has("repo")) {
+    repoPaths = await resolveRepoPaths({ home, cwd, explicitRepos, reposDirs, discover, maxRepos });
     sources.push(
-      await scanRepoSource({
-        repoPath,
+      await scanReposSource({
+        repoPaths,
         sinceMs,
-        maxDepth: 3,
+        maxDepth: REPO_DISCOVERY_DEPTH,
         maxFiles: maxFilesPerSource,
       }),
     );
@@ -127,7 +159,9 @@ export async function scanSources(options = {}) {
     scannedAt: new Date().toISOString(),
     platform: platform(),
     home,
-    repoPath,
+    repoPath: repoPaths[0] ?? null,
+    repoPaths,
+    reposScanned: repoPaths.length,
     sources,
     foundSources: foundSources.length,
     totals,
@@ -141,10 +175,10 @@ export function formatScanSummary(result) {
   lines.push(`Scanned sources: ${result.sources.length}`);
   lines.push(`Found sources: ${result.foundSources}`);
   lines.push(
-    `Candidate files: ${result.totals.files} (${result.totals.transcriptFiles} transcripts, ${result.totals.settingsFiles} settings, ${result.totals.ruleFiles} rules)`,
+    `Candidate files: ${result.totals.files} (${result.totals.ruleFiles} rules, ${result.totals.settingsFiles} settings, ${result.totals.transcriptFiles} transcripts)`,
   );
   lines.push(`Approx bytes: ${formatBytes(result.totals.bytes)}`);
-  if (result.repoPath) lines.push(`Repo context: ${result.repoPath}`);
+  if (result.reposScanned > 0) lines.push(`Repos discovered: ${result.reposScanned}`);
   lines.push("");
 
   for (const source of result.sources) {
@@ -153,38 +187,46 @@ export function formatScanSummary(result) {
     for (const root of source.roots) {
       lines.push(`  - ${root.exists ? "found" : "missing"} ${root.path}`);
     }
-    if (source.files.length > 0) {
-      for (const file of source.files.slice(0, 5)) {
+    const rules = source.files.filter((f) => f.kind === "rule");
+    const preview = [...rules, ...source.files.filter((f) => f.kind !== "rule")];
+    if (preview.length > 0) {
+      for (const file of preview.slice(0, 6)) {
         lines.push(`    ${file.kind}: ${file.path}`);
       }
-      if (source.files.length > 5) lines.push(`    ... ${source.files.length - 5} more`);
+      if (preview.length > 6) lines.push(`    ... ${preview.length - 6} more`);
     }
   }
 
   lines.push("");
-  lines.push("No raw transcript contents were uploaded.");
   return lines.join("\n");
 }
 
+const REDACT_PATTERNS = [
+  /sk-[a-zA-Z0-9]{20,}/g,
+  /npm_[a-zA-Z0-9]{20,}/g,
+  /ghp_[a-zA-Z0-9]{20,}/g,
+  /github_pat_[a-zA-Z0-9_]{20,}/g,
+  /xox[baprs]-[a-zA-Z0-9-]{10,}/g,
+  /AKIA[0-9A-Z]{16}/g,
+  /AIza[0-9A-Za-z-_]{35}/g,
+  /Bearer\s+[a-zA-Z0-9._-]{20,}/gi,
+  /token["\s:=]+["']?[a-zA-Z0-9._-]{20,}/gi,
+  /secret["\s:=]+["']?[a-zA-Z0-9._-]{20,}/gi,
+  /password["\s:=]+["']?\S+/gi,
+  /apikey["\s:=]+["']?\S+/gi,
+];
+
+function redact(text) {
+  let out = text;
+  for (const pat of REDACT_PATTERNS) out = out.replace(pat, "[REDACTED]");
+  return out;
+}
+
+// Read rule + settings file contents for upload. Rule contents are deduped by a
+// content hash so 28 worktrees of the same repo upload its rules once, not 28×.
 export async function readRulesContent(scanResult) {
   const out = { rulesContent: [], settingsSummary: [] };
-  const REDACT_PATTERNS = [
-    /sk-[a-zA-Z0-9]{20,}/g,
-    /npm_[a-zA-Z0-9]{20,}/g,
-    /ghp_[a-zA-Z0-9]{20,}/g,
-    /AIza[0-9A-Za-z-_]{35}/g,
-    /Bearer\s+[a-zA-Z0-9._-]{20,}/gi,
-    /token["\s:=]+["']?[a-zA-Z0-9._-]{20,}/gi,
-    /secret["\s:=]+["']?[a-zA-Z0-9._-]{20,}/gi,
-    /password["\s:=]+["']?\S+/gi,
-    /apikey["\s:=]+["']?\S+/gi,
-  ];
-
-  const redact = (text) => {
-    let redacted = text;
-    for (const pat of REDACT_PATTERNS) redacted = redacted.replace(pat, "[REDACTED]");
-    return redacted;
-  };
+  const seenRuleHashes = new Set();
 
   for (const source of scanResult.sources) {
     for (const file of source.files) {
@@ -192,8 +234,11 @@ export async function readRulesContent(scanResult) {
       if (file.bytes > 100_000) continue;
       try {
         const raw = await readFile(file.path, "utf8");
-        const content = redact(raw).slice(0, 8000);
         if (file.kind === "rule") {
+          const content = redact(raw).slice(0, 8000);
+          const h = hash(content);
+          if (seenRuleHashes.has(h)) continue;
+          seenRuleHashes.add(h);
           out.rulesContent.push({ source: source.id, path: file.path, content });
         } else {
           const summary = extractSettingsSummary(raw, source.id);
@@ -300,26 +345,143 @@ async function scanSource(input) {
   };
 }
 
-async function scanRepoSource(input) {
-  if (!input.repoPath) {
-    return {
-      id: "repo",
-      label: "Repo rules",
-      exists: false,
-      roots: [],
-      files: [],
-      truncated: false,
-    };
+// Aggregate rule files across every discovered repo into a single "repo" source.
+async function scanReposSource(input) {
+  const roots = [];
+  const files = [];
+  const seenPaths = new Set();
+
+  for (const repoPath of input.repoPaths) {
+    for (const root of repoRuleRoots(repoPath)) {
+      const expanded = expandHome(root.path);
+      const rootStat = await safeStat(expanded);
+      const exists = Boolean(rootStat);
+      if (roots.length < 40) roots.push({ path: expanded, role: root.role, exists });
+      if (!rootStat) continue;
+      if (rootStat.isDirectory()) {
+        const walked = await walkCandidateFiles(expanded, {
+          sourceId: "repo",
+          rootRole: root.role,
+          sinceMs: input.sinceMs,
+          includeTranscripts: false,
+          maxDepth: input.maxDepth,
+          maxFiles: input.maxFiles - files.length,
+        });
+        for (const f of walked.files) {
+          if (seenPaths.has(f.path)) continue;
+          seenPaths.add(f.path);
+          files.push(f);
+        }
+      } else if (rootStat.isFile()) {
+        const candidate = classifyCandidate(expanded, "repo", root.role);
+        if (candidate && passesFilters(candidate, rootStat, input.sinceMs, false) && !seenPaths.has(expanded)) {
+          seenPaths.add(expanded);
+          files.push(toFileSummary(expanded, candidate.kind, rootStat));
+        }
+      }
+    }
   }
-  return scanSource({
+
+  return {
     id: "repo",
     label: "Repo rules",
-    roots: repoRuleRoots(input.repoPath),
-    sinceMs: input.sinceMs,
-    includeTranscripts: false,
-    maxDepth: input.maxDepth,
-    maxFiles: input.maxFiles,
-  });
+    exists: files.length > 0,
+    roots,
+    files,
+    truncated: false,
+  };
+}
+
+// Build the full set of repos to scan: explicit (--repo), cwd, conventional
+// code roots, expanded --repos dirs, and local folders referenced by Cursor/VS
+// Code workspaces. Deduped.
+async function resolveRepoPaths({ home, cwd, explicitRepos, reposDirs, discover, maxRepos }) {
+  const found = new Set();
+
+  for (const p of explicitRepos) {
+    const root = await findRepoRoot(p);
+    if (root) found.add(root);
+  }
+  const cwdRoot = await findRepoRoot(cwd);
+  if (cwdRoot) found.add(cwdRoot);
+
+  if (discover) {
+    const parents = [...reposDirs];
+    for (const name of CODE_ROOTS) parents.push(path.join(home, name));
+    for (const parent of parents) {
+      if (found.size >= maxRepos) break;
+      await discoverReposUnder(parent, found, maxRepos);
+    }
+    for (const wsFolder of await workspaceFolders(home)) {
+      if (found.size >= maxRepos) break;
+      const root = await findRepoRoot(wsFolder);
+      if (root) found.add(root);
+    }
+  }
+
+  return [...found].slice(0, maxRepos);
+}
+
+async function discoverReposUnder(parent, found, maxRepos, depth = 0) {
+  if (found.size >= maxRepos || depth > REPO_DISCOVERY_DEPTH) return;
+  let entries;
+  try {
+    entries = await readdir(parent, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (found.size >= maxRepos) return;
+    if (!entry.isDirectory() || shouldSkipEntry(entry.name)) continue;
+    const dir = path.join(parent, entry.name);
+    if (await isRepoDir(dir)) {
+      found.add(dir);
+      continue; // don't descend into a repo
+    }
+    await discoverReposUnder(dir, found, maxRepos, depth + 1);
+  }
+}
+
+async function isRepoDir(dir) {
+  if (await exists(path.join(dir, ".git"))) return true;
+  return hasRepoRuleFile(dir);
+}
+
+// Local repo folders the user has open in Cursor / VS Code, read from each
+// workspace's workspace.json `folder` URI. Remote (ssh-remote, etc.) folders
+// are skipped — only file:// paths can have local rule files.
+async function workspaceFolders(home) {
+  const folders = [];
+  for (const base of [appSupportPath(home, "Cursor"), appSupportPath(home, "Code")]) {
+    const storage = path.join(base, "User", "workspaceStorage");
+    let dirs;
+    try {
+      dirs = await readdir(storage, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const d of dirs) {
+      if (!d.isDirectory()) continue;
+      try {
+        const raw = await readFile(path.join(storage, d.name, "workspace.json"), "utf8");
+        const folder = JSON.parse(raw)?.folder;
+        if (typeof folder === "string" && folder.startsWith("file://")) {
+          folders.push(fileUrlToPath(folder));
+        }
+      } catch {
+        // missing/unparseable workspace.json — skip
+      }
+    }
+  }
+  return folders;
+}
+
+function fileUrlToPath(url) {
+  try {
+    return decodeURIComponent(new URL(url).pathname);
+  } catch {
+    return url.replace(/^file:\/\//, "");
+  }
 }
 
 async function walkCandidateFiles(root, input, depth = 0) {
@@ -365,7 +527,7 @@ function classifyCandidate(filePath, sourceId, rootRole) {
   const normalized = filePath.split(path.sep).join("/");
 
   if (sourceId === "repo") {
-    if (base === "agents.md" || base === "claude.md" || base === ".cursorrules") return { kind: "rule" };
+    if (RULE_BASENAMES.has(base)) return { kind: "rule" };
     if (normalized.endsWith("/.github/copilot-instructions.md")) return { kind: "rule" };
     if (normalized.includes("/.cursor/rules/")) return { kind: "rule" };
     if (normalized.endsWith("/.vscode/settings.json")) return { kind: "settings" };
@@ -377,7 +539,7 @@ function classifyCandidate(filePath, sourceId, rootRole) {
   }
 
   if (base === "claude.json" || base === ".claude.json") return { kind: "settings" };
-  if (base === "agents.md" || base === "claude.md" || base === ".cursorrules") return { kind: "rule" };
+  if (RULE_BASENAMES.has(base)) return { kind: "rule" };
   if (rootRole === "transcripts" && TRANSCRIPT_EXTENSIONS.has(ext)) return { kind: "transcript" };
   if (rootRole === "workspace-storage" && (TRANSCRIPT_EXTENSIONS.has(ext) || base.endsWith(".vscdb"))) {
     return { kind: "transcript" };
@@ -404,6 +566,7 @@ function toFileSummary(filePath, kind, fileStat) {
 function claudeRoots(home) {
   return [
     { path: path.join(home, ".claude", "projects"), role: "transcripts" },
+    { path: path.join(home, ".claude", "CLAUDE.md"), role: "rules" },
     { path: path.join(home, ".claude", "settings.json"), role: "settings" },
     { path: path.join(home, ".claude.json"), role: "settings" },
   ];
@@ -501,7 +664,25 @@ async function safeStat(filePath) {
 }
 
 function shouldSkipEntry(name) {
-  return name === "node_modules" || name === ".git" || name === "vendor" || name === "dist" || name === "build";
+  return (
+    name === "node_modules" ||
+    name === ".git" ||
+    name === "vendor" ||
+    name === "dist" ||
+    name === "build" ||
+    name === "Library" ||
+    name === ".Trash"
+  );
+}
+
+// Small stable FNV-1a hash, used for content/message dedupe.
+function hash(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(36);
 }
 
 function formatBytes(bytes) {