replen 1.1.0 → 1.2.1

package/dist/index.js

@@ -26,6 +26,12 @@ Usage:
                              ~/.replen/atlas/ (projects, capabilities,
                              decisions, themes, all cross-linked)
   npx replen logout          Forget saved auth
+  npx replen uninstall       Remove Replen's local footprint (MCP wiring,
+       [--dry-run] [-y]      skills, per-repo doc blocks, ~/.replen). Asks
+       [--root PATH ...]     before each category; nothing goes without a yes.
+                             Server-side profile is untouched (delete that at
+                             app.replen.dev). --dry-run previews, -y skips
+                             prompts.
   npx replen --help          This help
 
 Use replen from a plain shell (no Claude Code / Codex needed):
@@ -96,6 +102,11 @@ async function main() {
         console.log(`\nRestart Claude Code to pick up the change.`);
         return;
     }
+    if (cmd === "uninstall") {
+        const { runUninstall } = await import("./uninstall.js");
+        await runUninstall(argv.slice(1));
+        return;
+    }
     if (cmd === "logout") {
         const { unlink } = await import("node:fs/promises");
         try {

package/dist/init.js

@@ -141,7 +141,14 @@ export async function runInit() {
         savedAt: new Date().toISOString(),
     });
     console.log(`  ✓ Saved auth to ${configPath()}`);
-    await setupMcp(exchange.token, exchange.base);
+    // Let the user choose, up front, which repos Replen works on. Default is
+    // ALL; a subset (or none) gates BOTH the doc-injection inside setupMcp
+    // AND the project registration below, so we never touch a repo they
+    // opted out of. Non-interactive / single-repo / no-repo cases keep the
+    // default automatically.
+    const { chooseRepoScope } = await import("./select-repos.js");
+    const { onlyRepos } = await chooseRepoScope();
+    await setupMcp(exchange.token, exchange.base, { onlyRepos });
     // Phase A: auto-discover the user's local projects, extract tags
     // from manifests, and register them in one shot. Replaces the
     // legacy "paste a GitHub PAT and let us call api.github.com" flow
@@ -149,7 +156,7 @@ export async function runInit() {
     console.log("");
     console.log("  Scanning your local repos for projects…");
     const { syncDiscoveredProjects } = await import("./sync-projects.js");
-    await syncDiscoveredProjects({ token: exchange.token, base: exchange.base });
+    await syncDiscoveredProjects({ token: exchange.token, base: exchange.base, onlyRepos });
     // Phase B: trigger the first ingest and stream progress until the
     // discovered pool is ready (~30-60s). Without this, a new user
     // would open Claude Code and find replen_match returning nothing —
@@ -159,13 +166,20 @@ export async function runInit() {
     const { runFirstIngest } = await import("./first-ingest.js");
     await runFirstIngest({ token: exchange.token, base: exchange.base, savedAt: "" });
     console.log("");
-    console.log("  All set. Restart Claude Code and try:");
-    console.log("    /replen       → triage today's candidates against this repo,");
-    console.log("                         in-session, using your subscription tokens");
-    console.log("    (no LLM API keys needed — the agent does the reasoning)");
+    console.log("  All set. Restart Claude Code, then do these two — IN THIS ORDER:");
     console.log("");
-    console.log("  Other MCP hosts (Codex / Cursor / Aider):");
-    console.log("    \"use replen_match\" — same tool, no slash command");
+    console.log("    1. /replen-onboard   ONE-TIME, FIRST. Reads your repos and builds a");
+    console.log("                         tailored profile so matches are relevant, not");
+    console.log("                         generic. Runs in the background — kick it off,");
+    console.log("                         then just keep working.");
+    console.log("");
+    console.log("    2. /replen           ANYTIME after that. Triages the candidates for");
+    console.log("                         the current repo, in-session, on your own");
+    console.log("                         subscription tokens — no LLM API key needed.");
+    console.log("");
+    console.log("  (Onboarding is once per project. After that, it's just /replen.)");
+    console.log("");
+    console.log("  Other MCP hosts (Codex / Cursor / Aider): \"use replen_match\" — same tool.");
     console.log("");
     console.log(`  Dashboard: ${exchange.base}`);
     console.log("");

package/dist/inject-instruction.js

@@ -33,12 +33,25 @@
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { join, basename } from "node:path";
 import { createInterface } from "node:readline";
-export const INTEGRATION_VERSION = "9";
+export const INTEGRATION_VERSION = "10";
 const SECTION_HEADER = "## Replen integration";
 const MARKER_RE = /<!--\s*replen-integration:\s*v(\d+)\s*-->/;
 const SECTION_BODY = `<!-- replen-integration: v${INTEGRATION_VERSION} -->
 
-On your **very first response** of each session:
+**FIRST, on your first response in a repo: check onboarding.** Call
+\`replen_onboard_state\` once. If it reports this repo (or the user's
+portfolio) is NOT yet onboarded/grounded, do NOT run the footnote flow
+this turn. Answer the user's message normally, then offer this VERBATIM
+as a new paragraph at the end:
+
+> Replen isn't set up for your repos yet — want me to do that now? Replen builds a profile so matches are relevant. Onboarding runs in the background, ~a few minutes.
+
+If they accept, invoke the \`replen-onboard\` skill. If they decline, carry
+on and do NOT re-offer for the rest of this session. Once \`replen_onboard_state\`
+shows the repo is onboarded, SKIP this check entirely and use the footnote
+flow below.
+
+Once onboarded, on your **very first response** of each session:
 
 1. **Skip the whole flow ONLY if** the user's first message is a
    pure trivial greeting with no content ("hi", "hey", "yo",
@@ -106,12 +119,21 @@ to say "you know I use scrapling elsewhere" — knowing is your job.
 // only repos that Replen can't match against anyway — the injected
 // instruction tells the agent to call `replen_match`, which is a no-op
 // without a registered project.
-async function discoverRepos(explicitRoots) {
+async function discoverRepos(explicitRoots, onlyRepos) {
     // Reuse sync-projects' resolveAndWalk via the previewDiscovery helper
     // so inject and sync-projects find the exact same set of repos.
     const { previewDiscovery } = await import("./sync-projects.js");
     const result = await previewDiscovery(explicitRoots);
-    return result.projects.map((p) => p.localPath);
+    let paths = result.projects.map((p) => p.localPath);
+    // Honour an explicit onboarding scope choice: when the user picked a
+    // subset of repos (or "none"), restrict doc-injection to exactly that
+    // set so we never edit a CLAUDE.md in a repo they opted out of.
+    // `undefined` means "no scope choice made" → inject into all (default).
+    if (onlyRepos !== undefined) {
+        const allow = new Set(onlyRepos);
+        paths = paths.filter((p) => allow.has(p));
+    }
+    return paths;
 }
 function applyToClaudeMd(claudeMdPath) {
     if (!existsSync(claudeMdPath)) {
@@ -251,7 +273,7 @@ async function promptYes(question) {
     });
 }
 export async function injectInstructions(opts = {}) {
-    const repos = await discoverRepos(opts.explicitRoots ?? []);
+    const repos = await discoverRepos(opts.explicitRoots ?? [], opts.onlyRepos);
     const outcome = {
         scanned: repos.length,
         created: 0,

package/dist/mcp-setup.js

@@ -75,7 +75,7 @@ const REPLEN_AUTO_ALLOW = [
 // ============================================================================
 // Public entry point
 // ============================================================================
-export async function setupMcp(token, base) {
+export async function setupMcp(token, base, opts = {}) {
     console.log(`  Wiring replen MCP into agent configs…`);
     // Pin the exact latest MCP version (deterministic; avoids npx serving a stale
     // `@^1` build and the spurious upgrade nudge that follows).
@@ -104,7 +104,7 @@ export async function setupMcp(token, base) {
     // call replen_match at session start. Idempotent + versioned.
     console.log("");
     const { injectInstructions, summariseOutcome } = await import("./inject-instruction.js");
-    const outcome = await injectInstructions();
+    const outcome = await injectInstructions({ onlyRepos: opts.onlyRepos });
     const summary = summariseOutcome(outcome);
     if (summary)
         console.log(summary);

package/dist/select-repos.js

@@ -0,0 +1,108 @@
+// Onboarding repo-scope choice. Run once during `npx replen`, AFTER auth
+// and BEFORE we wire MCP / inject docs / register projects, so the user
+// decides up front which of their repos Replen works on.
+//
+// Default is ALL — the cross-repo view (Atlas, Recall, far-away matches)
+// is the product's value, and most users want everything in. But a
+// cautious first-time user (or anyone testing) can scope to a subset, or
+// opt out entirely, and that choice gates BOTH server registration AND
+// the per-repo CLAUDE.md/AGENTS.md/GEMINI.md doc edits — Replen never
+// touches a repo they didn't pick.
+//
+// Returns `{ onlyRepos }`:
+//   - undefined  → "all" (no scope restriction; the default everywhere)
+//   - string[]   → exactly these absolute localPaths (may be empty = none)
+import { createInterface } from "node:readline/promises";
+import { previewDiscovery } from "./sync-projects.js";
+export async function chooseRepoScope() {
+    // Discover the same set inject + sync will see.
+    let projects = [];
+    try {
+        const result = await previewDiscovery([]);
+        projects = result.projects;
+    }
+    catch {
+        return {}; // discovery failed — fall back to default (all)
+    }
+    // Nothing to choose, or non-interactive (CI / hook / piped): keep the
+    // default. We never block onboarding on a prompt that can't be answered.
+    if (projects.length === 0)
+        return {};
+    if (!process.stdin.isTTY)
+        return {};
+    // A single repo isn't worth a selection menu — just include it.
+    if (projects.length === 1)
+        return {};
+    const home = process.env.HOME ?? "";
+    const label = (p) => {
+        const disp = home && p.localPath.startsWith(home) ? "~" + p.localPath.slice(home.length) : p.localPath;
+        return p.githubFullName ? `${p.githubFullName}  (${disp})` : disp;
+    };
+    console.log("");
+    console.log(`  Replen found ${projects.length} repos it can work with.`);
+    console.log("  Replen works best across all of them — that's how it spots a tool you");
+    console.log("  use in one project that fits another. You can also start with a subset.");
+    console.log("");
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const choice = (await rl.question("  Include  [A]ll (default) · [s]elect a subset · [n]one for now? "))
+            .trim()
+            .toLowerCase();
+        if (choice === "" || choice === "a" || choice === "all") {
+            return {}; // all
+        }
+        if (choice === "n" || choice === "none") {
+            console.log("  · None for now. Run `npx replen sync-projects` anytime to add them.");
+            return { onlyRepos: [] };
+        }
+        // Subset: show the numbered list and parse an inclusion spec.
+        console.log("");
+        projects.forEach((p, i) => console.log(`    ${String(i + 1).padStart(2)}. ${label(p)}`));
+        console.log("");
+        const spec = (await rl.question("  Numbers to include (e.g. 1,3,5 or 1-4,7), blank = all: ")).trim();
+        if (spec === "")
+            return {}; // blank ⇒ all
+        const picked = parseSelection(spec, projects.length);
+        if (picked.size === 0) {
+            console.log("  · Nothing parsed from that — including all.");
+            return {};
+        }
+        const onlyRepos = projects.filter((_, i) => picked.has(i + 1)).map((p) => p.localPath);
+        console.log(`  ✓ Including ${onlyRepos.length} of ${projects.length} repos.`);
+        return { onlyRepos };
+    }
+    catch {
+        return {}; // any prompt error ⇒ safe default (all)
+    }
+    finally {
+        rl.close();
+    }
+}
+// Parse "1,3,5" / "1-4" / "2-3,7" into a set of 1-based indices, clamped
+// to [1, max]. Tolerant of spaces and stray separators.
+export function parseSelection(spec, max) {
+    const out = new Set();
+    for (const part of spec.split(",")) {
+        const token = part.trim();
+        if (!token)
+            continue;
+        const range = token.match(/^(\d+)\s*-\s*(\d+)$/);
+        if (range) {
+            let lo = parseInt(range[1], 10);
+            let hi = parseInt(range[2], 10);
+            if (lo > hi)
+                [lo, hi] = [hi, lo];
+            for (let n = lo; n <= hi; n++)
+                if (n >= 1 && n <= max)
+                    out.add(n);
+            continue;
+        }
+        const single = token.match(/^\d+$/);
+        if (single) {
+            const n = parseInt(token, 10);
+            if (n >= 1 && n <= max)
+                out.add(n);
+        }
+    }
+    return out;
+}

package/dist/sync-projects.js

@@ -9,8 +9,14 @@
 import { readConfig, writeConfig } from "./config.js";
 import { discoverProjects } from "./discover-projects.js";
 import { promptForRoot, rootsFromClaudeJson, rootsFromConfig, rootsFromCwdWalkUp, rootsFromEnv, rootsFromFlag, rootsFromHardcoded, } from "./discover-roots.js";
-export async function syncDiscoveredProjects({ token, base, explicitRoots = [], }) {
+export async function syncDiscoveredProjects({ token, base, explicitRoots = [], onlyRepos, }) {
     const { result, source, prompted } = await resolveAndWalk(explicitRoots);
+    // Apply the onboarding scope choice before reporting / registering, so
+    // a user who picked a subset never has the opted-out repos registered.
+    if (onlyRepos !== undefined) {
+        const allow = new Set(onlyRepos);
+        result.projects = result.projects.filter((p) => allow.has(p.localPath));
+    }
     // Tell the user what we did, regardless of outcome.
     reportDiscovery(result, source);
     if (result.projects.length === 0) {

package/dist/uninstall.js

@@ -0,0 +1,504 @@
+// `npx replen uninstall` — reverse every local change `npx replen` made,
+// interactively and per-category, so a tester (or anyone) can cleanly back
+// out. The inverse of mcp-setup.ts + skill-install.ts + inject-instruction.ts.
+//
+// Design constraints (deliberate):
+//   - INTERACTIVE BY DEFAULT. Every destructive category asks its own
+//     y/N question, and the default is always NO. There is no single
+//     "nuke everything" keystroke — the user has to acknowledge each
+//     class of change so they understand what's being removed.
+//   - LOCAL ONLY. This touches the user's machine; it does NOT delete
+//     server-side data (project profiles, capabilities, matches). There
+//     is no account-delete endpoint yet — we tell the user how to request
+//     that separately rather than pretending we did it.
+//   - BACKUP BEFORE WRITE. Any host config we edit gets a timestamped
+//     `.bak` first, mirroring mcp-setup's contract, so even an unwanted
+//     removal is recoverable.
+//   - Per-repo doc edits are git-tracked, so stripping the Replen section
+//     shows up as a normal diff the user can review or revert.
+//
+// Flags:
+//   --yes / -y   Skip the per-category prompts (scripted / CI use). Still
+//                prints exactly what it removed.
+//   --dry-run    Show what WOULD be removed, change nothing.
+//   --root PATH  Extra root(s) to scan for repos with injected doc blocks
+//                (same semantics as `sync-projects --root`).
+import { readFileSync, writeFileSync, existsSync, rmSync, renameSync, chmodSync, mkdirSync, } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname, basename } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+import { configPath } from "./config.js";
+const SERVER_NAME = "replen";
+const CLAUDE_CONFIG = join(homedir(), ".claude.json");
+const CLAUDE_SETTINGS = join(homedir(), ".claude", "settings.json");
+const CODEX_CONFIG = join(homedir(), ".codex", "config.toml");
+const GEMINI_CONFIG = join(homedir(), ".gemini", "settings.json");
+const CLAUDE_SKILLS = join(homedir(), ".claude", "skills");
+const REPLEN_DIR = join(homedir(), ".replen");
+// Must match mcp-setup.ts: the tools it adds to permissions.allow and the
+// substring marker on the SessionStart hook command.
+const REPLEN_AUTO_ALLOW_PREFIX = "mcp__replen__";
+const HOOK_MARKER = "check-new --hook";
+// Must match inject-instruction.ts.
+const SECTION_HEADER = "## Replen integration";
+const MARKER_RE = /<!--\s*replen-integration:\s*v(\d+)\s*-->/;
+// The auto-generated stub header we write into a freshly-created doc, so we
+// can recognise a file that exists ONLY because Replen created it.
+const STUB_HINT = "the Replen integration section below is auto-managed";
+const SKILL_DIRS = ["replen", "replen-onboard"];
+export async function runUninstall(argv) {
+    const opts = {
+        yes: argv.includes("--yes") || argv.includes("-y"),
+        dryRun: argv.includes("--dry-run"),
+        explicitRoots: collectRoots(argv),
+    };
+    banner(opts);
+    // Top-level gate. Even with the per-category prompts below, the user
+    // confirms once up front that they understand what "uninstall" means.
+    if (!opts.yes && !opts.dryRun) {
+        const go = await confirm("Continue with uninstall?", false);
+        if (!go) {
+            console.log("\n  Nothing changed. Replen is still installed.");
+            return;
+        }
+    }
+    await removeMcpWiring(opts);
+    await removeSkills(opts);
+    await removeDocBlocks(opts);
+    await removeLocalConfig(opts);
+    console.log("");
+    if (opts.dryRun) {
+        console.log("  Dry run — nothing was changed. Re-run without --dry-run to apply.");
+    }
+    else {
+        console.log("  Done. Restart Claude Code / Codex / Gemini to drop the MCP server.");
+    }
+    console.log("");
+    console.log("  Note: this removed Replen from THIS machine only. Your server-side");
+    console.log("  profile (project capabilities, match history) still exists. To delete");
+    console.log("  that too, sign in at https://app.replen.dev and use account deletion,");
+    console.log("  or email support@replen.dev to request a full purge.");
+}
+// ============================================================================
+// Category 1 — MCP wiring across the three host configs + the allowlist + hook
+// ============================================================================
+async function removeMcpWiring(opts) {
+    // Probe what's actually present so we don't prompt about nothing.
+    const targets = [
+        {
+            label: "Claude Code MCP + SessionStart hook",
+            path: CLAUDE_CONFIG,
+            present: () => jsonHasServer(CLAUDE_CONFIG) || jsonHasHook(CLAUDE_CONFIG),
+            remove: () => stripClaudeConfig(),
+        },
+        {
+            label: "Claude Code tool allowlist",
+            path: CLAUDE_SETTINGS,
+            present: () => jsonHasAllow(CLAUDE_SETTINGS),
+            remove: () => stripClaudeAllowlist(),
+        },
+        {
+            label: "Codex MCP server",
+            path: CODEX_CONFIG,
+            present: () => tomlHasServer(CODEX_CONFIG),
+            remove: () => stripTomlServer(CODEX_CONFIG),
+        },
+        {
+            label: "Gemini CLI MCP server",
+            path: GEMINI_CONFIG,
+            present: () => jsonHasServer(GEMINI_CONFIG),
+            remove: () => stripJsonServer(GEMINI_CONFIG),
+        },
+    ];
+    const found = targets.filter((t) => safe(t.present));
+    if (found.length === 0) {
+        console.log("\n  ① MCP wiring — none found, skipping.");
+        return;
+    }
+    console.log("\n  ① MCP wiring found in:");
+    for (const t of found)
+        console.log(`       • ${t.label}  (${t.path})`);
+    if (!(await gate(opts, "Remove the replen MCP entries above?"))) {
+        console.log("       · kept.");
+        return;
+    }
+    if (opts.dryRun)
+        return;
+    for (const t of found) {
+        try {
+            t.remove();
+            console.log(`       ✓ removed: ${t.label}`);
+        }
+        catch (e) {
+            console.warn(`       ⚠ ${t.label}: ${e.message}`);
+        }
+    }
+}
+// ============================================================================
+// Category 2 — installed skills
+// ============================================================================
+async function removeSkills(opts) {
+    const present = SKILL_DIRS.map((n) => join(CLAUDE_SKILLS, n)).filter((p) => existsSync(p));
+    if (present.length === 0) {
+        console.log("\n  ② Skills — none found, skipping.");
+        return;
+    }
+    console.log("\n  ② Installed skills:");
+    for (const p of present)
+        console.log(`       • ${p}`);
+    if (!(await gate(opts, "Remove these skill directories?"))) {
+        console.log("       · kept.");
+        return;
+    }
+    if (opts.dryRun)
+        return;
+    for (const p of present) {
+        try {
+            rmSync(p, { recursive: true, force: true });
+            console.log(`       ✓ removed: ${basename(p)}`);
+        }
+        catch (e) {
+            console.warn(`       ⚠ ${p}: ${e.message}`);
+        }
+    }
+}
+// ============================================================================
+// Category 3 — the "## Replen integration" block in per-repo doc files
+// ============================================================================
+async function removeDocBlocks(opts) {
+    let repos = [];
+    try {
+        const { previewDiscovery } = await import("./sync-projects.js");
+        const result = await previewDiscovery(opts.explicitRoots);
+        repos = result.projects.map((p) => p.localPath);
+    }
+    catch {
+        repos = [];
+    }
+    // Find every doc file under those repos that carries our section.
+    const hits = [];
+    for (const repo of repos) {
+        for (const fileName of ["CLAUDE.md", "AGENTS.md", "GEMINI.md"]) {
+            const file = join(repo, fileName);
+            if (!existsSync(file))
+                continue;
+            let text;
+            try {
+                text = readFileSync(file, "utf8");
+            }
+            catch {
+                continue;
+            }
+            if (!hasReplenSection(text))
+                continue;
+            hits.push({ file, stubOnly: isStubOnly(text) });
+        }
+    }
+    if (hits.length === 0) {
+        console.log("\n  ③ Per-repo doc edits — none found, skipping.");
+        if (repos.length === 0) {
+            console.log("       (no repos discovered — pass --root PATH if your code lives somewhere non-conventional)");
+        }
+        return;
+    }
+    console.log(`\n  ③ "${SECTION_HEADER}" blocks found in ${hits.length} file(s):`);
+    for (const h of hits.slice(0, 10)) {
+        console.log(`       • ${h.file}${h.stubOnly ? "   (Replen-created — will delete whole file)" : "   (strip section, keep your content)"}`);
+    }
+    if (hits.length > 10)
+        console.log(`       … and ${hits.length - 10} more`);
+    console.log("       These are git-tracked, so the change shows as a normal diff you can review.");
+    if (!(await gate(opts, "Strip the Replen section from these files?"))) {
+        console.log("       · kept.");
+        return;
+    }
+    if (opts.dryRun)
+        return;
+    for (const h of hits) {
+        try {
+            if (h.stubOnly) {
+                rmSync(h.file, { force: true });
+                console.log(`       ✓ deleted (Replen-created): ${h.file}`);
+            }
+            else {
+                writeFileSync(h.file, stripReplenSection(readFileSync(h.file, "utf8")));
+                console.log(`       ✓ stripped section: ${h.file}`);
+            }
+        }
+        catch (e) {
+            console.warn(`       ⚠ ${h.file}: ${e.message}`);
+        }
+    }
+}
+// ============================================================================
+// Category 4 — ~/.replen (auth token + saved roots + Atlas vault export)
+// ============================================================================
+async function removeLocalConfig(opts) {
+    if (!existsSync(REPLEN_DIR)) {
+        console.log("\n  ④ Local config (~/.replen) — none found, skipping.");
+        return;
+    }
+    const cfg = existsSync(configPath());
+    const atlas = existsSync(join(REPLEN_DIR, "atlas"));
+    console.log("\n  ④ Local Replen directory:");
+    console.log(`       • ${REPLEN_DIR}`);
+    if (cfg)
+        console.log("         - config.json (auth token + saved project roots)");
+    if (atlas)
+        console.log("         - atlas/ (your exported knowledge-graph vault)");
+    if (!(await gate(opts, "Remove ~/.replen entirely?"))) {
+        console.log("       · kept (you stay signed in).");
+        return;
+    }
+    if (opts.dryRun)
+        return;
+    try {
+        rmSync(REPLEN_DIR, { recursive: true, force: true });
+        console.log("       ✓ removed: ~/.replen");
+    }
+    catch (e) {
+        console.warn(`       ⚠ ${REPLEN_DIR}: ${e.message}`);
+    }
+}
+// ============================================================================
+// Host-config mutation helpers (mirror mcp-setup's read/backup/atomic-write)
+// ============================================================================
+function jsonHasServer(path) {
+    const c = readJson(path);
+    const servers = c.mcpServers;
+    return !!servers && SERVER_NAME in servers;
+}
+function jsonHasHook(path) {
+    const c = readJson(path);
+    const ss = c.hooks?.SessionStart;
+    if (!Array.isArray(ss))
+        return false;
+    return ss.some((e) => (e.hooks ?? []).some((h) => typeof h.command === "string" && h.command.includes(HOOK_MARKER)));
+}
+function jsonHasAllow(path) {
+    const c = readJson(path);
+    const allow = c.permissions?.allow;
+    return Array.isArray(allow) && allow.some((a) => typeof a === "string" && a.startsWith(REPLEN_AUTO_ALLOW_PREFIX));
+}
+function tomlHasServer(path) {
+    const c = readTomlSafe(path);
+    const servers = c.mcp_servers;
+    return !!servers && SERVER_NAME in servers;
+}
+// Remove mcpServers.replen AND our SessionStart hook from ~/.claude.json.
+function stripClaudeConfig() {
+    const c = readJson(CLAUDE_CONFIG);
+    const servers = c.mcpServers ?? {};
+    delete servers[SERVER_NAME];
+    const hooks = c.hooks ?? {};
+    const ss = hooks.SessionStart ?? [];
+    const cleanedSS = ss.filter((e) => !(e.hooks ?? []).some((h) => typeof h.command === "string" && h.command.includes(HOOK_MARKER)));
+    const nextHooks = { ...hooks };
+    if (cleanedSS.length > 0)
+        nextHooks.SessionStart = cleanedSS;
+    else
+        delete nextHooks.SessionStart;
+    const next = { ...c, mcpServers: servers };
+    if (Object.keys(nextHooks).length > 0)
+        next.hooks = nextHooks;
+    else
+        delete next.hooks;
+    if (Object.keys(servers).length === 0)
+        delete next.mcpServers;
+    backupIfExists(CLAUDE_CONFIG);
+    writeJsonAtomic(CLAUDE_CONFIG, next);
+}
+function stripClaudeAllowlist() {
+    const c = readJson(CLAUDE_SETTINGS);
+    const permissions = c.permissions ?? {};
+    const allow = Array.isArray(permissions.allow) ? permissions.allow : [];
+    const kept = allow.filter((a) => !(typeof a === "string" && a.startsWith(REPLEN_AUTO_ALLOW_PREFIX)));
+    const nextPerms = { ...permissions };
+    if (kept.length > 0)
+        nextPerms.allow = kept;
+    else
+        delete nextPerms.allow;
+    const next = { ...c };
+    if (Object.keys(nextPerms).length > 0)
+        next.permissions = nextPerms;
+    else
+        delete next.permissions;
+    backupIfExists(CLAUDE_SETTINGS);
+    writeJsonAtomic(CLAUDE_SETTINGS, next);
+}
+function stripJsonServer(path) {
+    const c = readJson(path);
+    const servers = c.mcpServers ?? {};
+    delete servers[SERVER_NAME];
+    const next = { ...c, mcpServers: servers };
+    if (Object.keys(servers).length === 0)
+        delete next.mcpServers;
+    backupIfExists(path);
+    writeJsonAtomic(path, next);
+}
+function stripTomlServer(path) {
+    const c = readTomlSafe(path);
+    const servers = c.mcp_servers ?? {};
+    delete servers[SERVER_NAME];
+    const next = { ...c, mcp_servers: servers };
+    if (Object.keys(servers).length === 0)
+        delete next.mcp_servers;
+    backupIfExists(path);
+    writeTomlAtomic(path, next);
+}
+// ============================================================================
+// Doc-section helpers (mirror inject-instruction's section anchoring)
+// ============================================================================
+function hasReplenSection(text) {
+    return text.split("\n").some((l) => l.trim() === SECTION_HEADER);
+}
+// A file is "stub only" if Replen created it: it carries our generated stub
+// hint AND contains nothing but the header + the Replen section. Removing the
+// section would leave an empty husk, so we delete the whole file instead.
+function isStubOnly(text) {
+    if (!text.includes(STUB_HINT))
+        return false;
+    const stripped = stripReplenSection(text).trim();
+    // After removing the section, all that's left is the auto-generated H1 +
+    // stub comment. If there's no other prose, treat it as Replen-owned.
+    const meaningful = stripped
+        .split("\n")
+        .filter((l) => l.trim() && !l.trim().startsWith("# ") && !l.trim().startsWith("<!--"))
+        .join("")
+        .trim();
+    return meaningful.length === 0;
+}
+// Remove the `## Replen integration` block: from its H2 header to the next H2
+// (not H3+) or EOF. Mirrors replaceSection() in inject-instruction.ts but
+// deletes rather than replaces. Collapses any duplicate blocks too.
+function stripReplenSection(text) {
+    let out = text;
+    // Loop until no section remains (defends against legacy duplicate blocks).
+    // Bounded to avoid any pathological non-progress.
+    for (let guard = 0; guard < 10; guard++) {
+        const lines = out.split("\n");
+        let start = -1;
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].trim() === SECTION_HEADER) {
+                start = i;
+                break;
+            }
+        }
+        if (start === -1)
+            break;
+        let end = lines.length;
+        for (let j = start + 1; j < lines.length; j++) {
+            if (lines[j].startsWith("## ") && !lines[j].startsWith("### ")) {
+                end = j;
+                break;
+            }
+        }
+        const before = lines.slice(0, start).join("\n").replace(/\n+$/, "");
+        const after = end < lines.length ? lines.slice(end).join("\n") : "";
+        out = (before + (after ? "\n\n" + after : "\n")).replace(/\n{3,}/g, "\n\n");
+    }
+    void MARKER_RE; // marker presence already implied by header; kept for parity
+    return out.replace(/\s+$/, "") + "\n";
+}
+// ============================================================================
+// File primitives
+// ============================================================================
+function readJson(path) {
+    if (!existsSync(path))
+        return {};
+    const raw = readFileSync(path, "utf8");
+    if (!raw.trim())
+        return {};
+    return JSON.parse(raw);
+}
+function readTomlSafe(path) {
+    if (!existsSync(path))
+        return {};
+    const raw = readFileSync(path, "utf8");
+    if (!raw.trim())
+        return {};
+    return parseToml(raw);
+}
+function writeJsonAtomic(path, data) {
+    writeAtomic(path, JSON.stringify(data, null, 2) + "\n");
+}
+function writeTomlAtomic(path, data) {
+    writeAtomic(path, stringifyToml(data) + "\n");
+}
+function writeAtomic(path, content) {
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.tmp.${Date.now()}`;
+    writeFileSync(tmp, content, { mode: 0o600 });
+    renameSync(tmp, path);
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch {
+        /* best-effort */
+    }
+}
+function backupIfExists(path) {
+    if (!existsSync(path))
+        return;
+    const ts = new Date().toISOString().replace(/[:.]/g, "-");
+    writeFileSync(`${path}.bak.${ts}`, readFileSync(path));
+}
+// ============================================================================
+// CLI plumbing
+// ============================================================================
+function banner(opts) {
+    console.log("");
+    console.log("  Replen uninstall — removes Replen's LOCAL footprint from this machine.");
+    console.log("  You'll be asked before each category; nothing is removed without a yes.");
+    if (opts.dryRun)
+        console.log("  (--dry-run: previewing only, no changes)");
+    console.log("");
+    console.log("  In scope:  MCP wiring (Claude/Codex/Gemini), the /replen skills,");
+    console.log("             the per-repo \"## Replen integration\" doc blocks, and ~/.replen.");
+    console.log("  NOT in scope: server-side profiles & match history (see note at the end).");
+}
+// Per-category gate. --yes bypasses (scripted). Default is NO.
+async function gate(opts, question) {
+    if (opts.dryRun)
+        return true; // show what would happen, but caller no-ops
+    if (opts.yes)
+        return true;
+    return confirm(question, false);
+}
+async function confirm(question, defaultYes) {
+    if (!process.stdin.isTTY)
+        return false; // non-interactive + no --yes ⇒ refuse to delete
+    const hint = defaultYes ? "[Y/n]" : "[y/N]";
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const ans = (await rl.question(`       ${question} ${hint} `)).trim().toLowerCase();
+        if (ans === "")
+            return defaultYes;
+        return ans === "y" || ans === "yes";
+    }
+    catch {
+        return false;
+    }
+    finally {
+        rl.close();
+    }
+}
+function collectRoots(argv) {
+    const out = [];
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === "--root" && argv[i + 1])
+            out.push(argv[++i]);
+        else if (argv[i].startsWith("--root="))
+            out.push(argv[i].slice("--root=".length));
+    }
+    return out;
+}
+function safe(fn) {
+    try {
+        return fn();
+    }
+    catch {
+        return false;
+    }
+}

package/extras/skills/replen/SKILL.md

@@ -40,7 +40,10 @@ Parse the JSON response. Note:
 
 - `filterMode` — `tags`, `zero-knowledge`, or `fingerprint`
 - `scopedTo` — confirms the project context the user has open
-- `candidates[]` — the actual list to triage
+- `candidates[]` — the actual list to triage. Each carries `solid: true|false` —
+  the ones Replen counts as genuinely worth your time (clear domain-fit + posture +
+  not-already-covered, or a dependency-maintenance match). The footnote's count is
+  the number of `solid` ones; the rest are "worth a glance" laterals.
 
 If `candidates.length === 0`, tell the user "No new candidates today for
 `<owner/name>`. Calm-cadence working as designed — 1-3 actionable
@@ -50,8 +53,11 @@ If 1+ candidates, continue.
 
 ### Step 3 — Per-candidate analysis
 
-**Cap at 5 candidates.** If the inventory returned more, take the top 5
-by `whyShortlisted` strength + stars + recency, defer the rest.
+**Triage the `solid` candidates first** (cap at 5). If there are more than 5
+solid, take the top 5 by `whyShortlisted` strength + stars + recency. The
+non-`solid` "worth a glance" entries are optional — skim them only if the solid
+set is thin or the user asks. A low-domain-fit lateral there can still be a real
+port/cherry-pick, so don't dismiss them blindly, but they're not the headline.
 
 For each candidate, do this loop:
 
@@ -210,9 +216,15 @@ For tech-news-site:
 
 (Triaged 9 candidates; surfacing the 2 worth acting on + 1 idea worth keeping.)
 
-What would you like to do with each? (star / hide / handoff)
+What would you like to do with each? — star (save it for later; won't
+re-surface), hide (dismiss; never show again), or handoff (open a pull
+request against your repo for it). Or skip and decide later.
 ```
 
+Always present the options WITH that one-line gloss the first time in a
+session — never the bare "(star / hide / handoff)". A new user doesn't know
+what they mean, and the calm-cadence promise dies if the user has to ask.
+
 The one-line "(Triaged N…)" footer is the *only* acknowledgement that skips
 happened — honest, but it doesn't parade them.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replen",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "Make your AI coding tools smarter. One command, no API keys, free. Replen watches what your projects actually do and surfaces a few things worth bringing in each month. Use one as is, port a piece of another, cherry pick an idea, or build it clean room. The match happens inside your AI tool's session. A few actionable matches a month, by design.",
   "type": "module",
   "bin": {