@popoverai/dotrequirements 0.25.0 → 0.26.0

package/dist/cli.js

@@ -64,7 +64,13 @@ program
     .action(wrapCommand(initCommand));
 program
     .command("link")
-    .description("Link local environment to an existing project")
+    .description("Link local environment to a cloud project (creating one when needed)")
+    .option("-y, --yes", "Non-interactive: resolve every decision from defaults or flags; never prompt")
+    .option("--json", "Machine-readable output (one JSON object on stdout)")
+    .option("--team <nameOrId>", "Use this team (implies --yes)")
+    .option("--connect <slug>", "Connect to this existing project (implies --yes)")
+    .option("--create", "Create a new project (implies --yes)")
+    .option("-n, --name <name>", "Project name for --create or rename")
     .action(wrapCommand(linkCommand));
 program
     .command("pull")
@@ -125,6 +131,7 @@ program
 program
     .command("ai-setup")
     .description("Configure MCP server for your AI assistant (Claude Code, Claude Desktop, etc.)")
+    .option("-a, --assistant <id>", "Configure for this assistant without prompting (e.g. claude-code)")
     .action(wrapCommand(aiSetupCommand));
 program
     .command("search <query>")

package/dist/codebase-to-spec/present.d.ts

@@ -85,6 +85,15 @@ export declare function splitComposedSpec(composed: string, outline: Outline): M
  * We just read it and return it.
  */
 export declare function buildSingleFileDoc(composedSpec: string): string;
+/**
+ * Insert the run marker as a top-level frontmatter field (IMPORT-1.0).
+ *
+ * At push time, a valid marker on a newly-created document grants its rows
+ * `imported` authorship — exempt from the requirement limit (IMPORT-2).
+ * Returns the content unchanged when it has no frontmatter block (defensive;
+ * present output always has one).
+ */
+export declare function stampRunMarker(content: string, marker: string): string;
 /**
  * Build a per-area requirements document for split mode.
  */

package/dist/codebase-to-spec/present.js

@@ -16,6 +16,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { parseRequirementsFile } from "../schema/parser.js";
+import { generateRunMarker } from "../schema/run-marker.js";
 import { sanitizeAreaName } from "./fan-out.js";
 import { promptOverwriteChoice } from "./interactive.js";
 export const AREA_SPLIT_THRESHOLD = 5;
@@ -113,6 +114,20 @@ export function splitComposedSpec(composed, outline) {
 export function buildSingleFileDoc(composedSpec) {
     return composedSpec;
 }
+/**
+ * Insert the run marker as a top-level frontmatter field (IMPORT-1.0).
+ *
+ * At push time, a valid marker on a newly-created document grants its rows
+ * `imported` authorship — exempt from the requirement limit (IMPORT-2).
+ * Returns the content unchanged when it has no frontmatter block (defensive;
+ * present output always has one).
+ */
+export function stampRunMarker(content, marker) {
+    if (!content.startsWith("---\n")) {
+        return content;
+    }
+    return `---\nctsRun: ${marker}\n${content.slice(4)}`;
+}
 /**
  * Build a per-area requirements document for split mode.
  */
@@ -211,11 +226,14 @@ export async function runPresent(options) {
     const composedSpec = readFileSync(finalSpecPath, "utf-8");
     const plan = planPresentPaths(outline, projectRoot, outputSubdir);
     // Compute the content for each output up front.
+    // IMPORT-1.0/1.1: one run marker per present invocation, stamped into every
+    // document this run produces.
+    const runMarker = generateRunMarker();
     const planned = [];
     if (plan.mode === "single") {
         planned.push({
             outPath: plan.paths[0].outPath,
-            content: buildSingleFileDoc(composedSpec),
+            content: stampRunMarker(buildSingleFileDoc(composedSpec), runMarker),
         });
     }
     else {
@@ -223,7 +241,10 @@ export async function runPresent(options) {
         for (const { area, outPath } of plan.paths) {
             const body = sections.get(area) ??
                 "_(no content for this area was found in the composed spec)_";
-            planned.push({ outPath, content: buildAreaDoc(outline, area, body) });
+            planned.push({
+                outPath,
+                content: stampRunMarker(buildAreaDoc(outline, area, body), runMarker),
+            });
         }
     }
     // In fail-fast mode, scan for any conflict before writing anything.

package/dist/codebase-to-spec/skill-install.d.ts

@@ -59,17 +59,27 @@ export interface SkillInstallResult {
  */
 export declare function resolveSkillDir(options: SkillInstallOptions): string;
 /**
- * Load the bundled SKILL.md template from the package.
+ * Resolve the CLI invocation stamped into the installed artifacts
+ * (CTSO-INSTALL-5): a version-pinned `npx` invocation of this very package,
+ * so the installed bundle runs without `dotrequirements` on PATH and always
+ * shells out to the same CLI version that performed the install.
  */
-export declare function loadSkillTemplate(): string;
+export declare function resolveCliInvocation(): string;
 /**
- * Load the bundled cts-worker agent definition template.
+ * Load the bundled SKILL.md template, rendering `{{DOTREQ_CLI}}` to the given
+ * CLI invocation (defaults to the version-pinned npx form).
  */
-export declare function loadAgentTemplate(): string;
+export declare function loadSkillTemplate(cliInvocation?: string): string;
 /**
- * Load the bundled specify-codebase dynamic-workflow script template.
+ * Load the bundled cts-worker agent definition template, rendering
+ * `{{DOTREQ_CLI}}` to the given CLI invocation.
  */
-export declare function loadWorkflowTemplate(): string;
+export declare function loadAgentTemplate(cliInvocation?: string): string;
+/**
+ * Load the bundled specify-codebase dynamic-workflow script template,
+ * rendering `{{DOTREQ_CLI}}` to the given CLI invocation.
+ */
+export declare function loadWorkflowTemplate(cliInvocation?: string): string;
 /**
  * Install (or refuse to overwrite) the codebase-to-spec skill bundle.
  *

package/dist/codebase-to-spec/skill-install.js

@@ -17,9 +17,11 @@
  * - CTS-SKILL-1, CTS-SKILL-5
  * - CTSO-INSTALL-1 (bundles the skill, the cts-worker agent, and the workflow)
  */
+import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
+import { getOwnPackage } from "../utils/own-package.js";
 import { loadTemplate } from "../utils/templates.js";
 /**
  * Resolve the directory in which the skill should live, given the user's
@@ -45,39 +47,76 @@ export function resolveSkillDir(options) {
     }
 }
 /**
- * Load the bundled SKILL.md template from the package.
+ * Resolve the CLI invocation stamped into the installed artifacts
+ * (CTSO-INSTALL-5): a version-pinned `npx` invocation of this very package,
+ * so the installed bundle runs without `dotrequirements` on PATH and always
+ * shells out to the same CLI version that performed the install.
  */
-export function loadSkillTemplate() {
-    return loadTemplate("skills/codebase-to-spec/SKILL.md");
+export function resolveCliInvocation() {
+    const pkg = getOwnPackage();
+    return `npx -y ${pkg.name}@${pkg.version}`;
 }
 /**
- * Load the bundled cts-worker agent definition template.
+ * Load the bundled SKILL.md template, rendering `{{DOTREQ_CLI}}` to the given
+ * CLI invocation (defaults to the version-pinned npx form).
  */
-export function loadAgentTemplate() {
-    return loadTemplate("agents/cts-worker.md");
+export function loadSkillTemplate(cliInvocation = resolveCliInvocation()) {
+    return loadTemplate("skills/codebase-to-spec/SKILL.md", {
+        DOTREQ_CLI: cliInvocation,
+    });
 }
 /**
- * Load the bundled specify-codebase dynamic-workflow script template.
+ * Load the bundled cts-worker agent definition template, rendering
+ * `{{DOTREQ_CLI}}` to the given CLI invocation.
  */
-export function loadWorkflowTemplate() {
-    return loadTemplate("workflows/specify-codebase.js");
+export function loadAgentTemplate(cliInvocation = resolveCliInvocation()) {
+    return loadTemplate("agents/cts-worker.md", { DOTREQ_CLI: cliInvocation });
 }
 /**
- * Install (or refuse to overwrite) one template file at a target path.
- * Returns true if a write happened.
+ * Load the bundled specify-codebase dynamic-workflow script template,
+ * rendering `{{DOTREQ_CLI}}` to the given CLI invocation.
  */
-function installTemplateFile(templateContent, targetPath, overwrite, description) {
-    const exists = existsSync(targetPath);
-    if (exists && !overwrite) {
-        const onDisk = readFileSync(targetPath, "utf-8");
-        if (onDisk === templateContent) {
-            return { installed: false, overwrote: false };
-        }
-        throw new Error(`${description} already exists at ${targetPath} and differs from the bundled template. Pass --overwrite to replace it, or delete the file first.`);
+export function loadWorkflowTemplate(cliInvocation = resolveCliInvocation()) {
+    return loadTemplate("workflows/specify-codebase.js", {
+        DOTREQ_CLI: cliInvocation,
+    });
+}
+/**
+ * Manifest written next to the installed SKILL.md, recording the content hash
+ * of every file the install wrote. On a later re-run, an on-disk file whose
+ * hash still matches its manifest entry is a *stock* install (possibly from an
+ * older CLI version) and is safe to refresh without --overwrite; a mismatch
+ * means the user hand-edited it (CTSO-INSTALL-6).
+ */
+const MANIFEST_FILENAME = ".install-manifest.json";
+function sha256(content) {
+    return createHash("sha256").update(content, "utf-8").digest("hex");
+}
+function readManifest(skillDir) {
+    const manifestPath = join(skillDir, MANIFEST_FILENAME);
+    if (!existsSync(manifestPath))
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(manifestPath, "utf-8"));
+    }
+    catch {
+        // An unreadable manifest gives no provenance; fall back to treating
+        // differing files as hand-edited (the safe direction).
+        return undefined;
+    }
+}
+function classifyPiece(key, description, targetPath, content, manifest) {
+    if (!existsSync(targetPath)) {
+        return { key, description, targetPath, content, state: "missing" };
     }
-    mkdirSync(dirname(targetPath), { recursive: true });
-    writeFileSync(targetPath, templateContent, "utf-8");
-    return { installed: true, overwrote: exists };
+    const onDisk = readFileSync(targetPath, "utf-8");
+    if (onDisk === content) {
+        return { key, description, targetPath, content, state: "current" };
+    }
+    if (manifest?.files[key] === sha256(onDisk)) {
+        return { key, description, targetPath, content, state: "stock" };
+    }
+    return { key, description, targetPath, content, state: "modified" };
 }
 /**
  * Install (or refuse to overwrite) the codebase-to-spec skill bundle.
@@ -92,37 +131,60 @@ function installTemplateFile(templateContent, targetPath, overwrite, description
 export function installSkill(options = {}) {
     const skillDir = resolveSkillDir(options);
     const skillPath = join(skillDir, "SKILL.md");
-    const skillTemplate = loadSkillTemplate();
-    const skillResult = installTemplateFile(skillTemplate, skillPath, options.overwrite === true, "SKILL.md");
+    const scope = options.scope ?? "project";
+    const cliInvocation = resolveCliInvocation();
+    const manifest = readManifest(skillDir);
+    // Classify every piece before writing anything, so a hand-edit refusal
+    // never leaves a partially refreshed bundle (CTSO-INSTALL-6).
+    const pieces = [
+        classifyPiece("skill", "SKILL.md", skillPath, loadSkillTemplate(cliInvocation), manifest),
+    ];
     // A custom target dir is an arbitrary location CC won't read agents or
     // workflows from, so it gets the skill body only. Project and global both
     // install the full bundle under their `.claude/` base.
-    const scope = options.scope ?? "project";
-    if (scope === "custom") {
-        return {
-            installedPath: skillPath,
-            installed: skillResult.installed,
-            overwrote: skillResult.overwrote,
-        };
+    let companions;
+    if (scope !== "custom") {
+        const claudeBase = scope === "global"
+            ? join(options.globalRoot ?? homedir(), ".claude")
+            : join(options.projectRoot ?? process.cwd(), ".claude");
+        const agentPath = join(claudeBase, "agents", "cts-worker.md");
+        const workflowPath = join(claudeBase, "workflows", "specify-codebase.js");
+        pieces.push(classifyPiece("agent", "cts-worker agent definition", agentPath, loadAgentTemplate(cliInvocation), manifest), 
+        // The workflow script is discovered by name from .claude/workflows/;
+        // no settings registration needed, unlike a hook.
+        classifyPiece("workflow", "specify-codebase workflow script", workflowPath, loadWorkflowTemplate(cliInvocation), manifest));
+        companions = { agentPath, workflowPath };
     }
-    const claudeBase = scope === "global"
-        ? join(options.globalRoot ?? homedir(), ".claude")
-        : join(options.projectRoot ?? process.cwd(), ".claude");
-    const agentPath = join(claudeBase, "agents", "cts-worker.md");
-    const workflowPath = join(claudeBase, "workflows", "specify-codebase.js");
-    // Install the cts-worker agent definition.
-    installTemplateFile(loadAgentTemplate(), agentPath, options.overwrite === true, "cts-worker agent definition");
-    // Install the specify-codebase workflow script (discovered by name from
-    // .claude/workflows/; no settings registration needed, unlike a hook).
-    installTemplateFile(loadWorkflowTemplate(), workflowPath, options.overwrite === true, "specify-codebase workflow script");
+    // Hand-edited files block the whole refresh (named individually) unless
+    // --overwrite; unmodified-stock files from any prior version refresh freely.
+    if (options.overwrite !== true) {
+        const modified = pieces.filter((p) => p.state === "modified");
+        if (modified.length > 0) {
+            const lines = modified.map((p) => `  ${p.description}: ${p.targetPath}`);
+            throw new Error(`Refusing to replace file(s) modified since install (or installed without manifest tracking):\n${lines.join("\n")}\nPass --overwrite to replace, or delete the file(s) first.`);
+        }
+    }
+    const skillPiece = pieces[0];
+    for (const piece of pieces) {
+        if (piece.state === "current")
+            continue;
+        mkdirSync(dirname(piece.targetPath), { recursive: true });
+        writeFileSync(piece.targetPath, piece.content, "utf-8");
+    }
+    // Record what this install wrote (or confirmed current) so the next re-run
+    // can tell stock content from hand-edits. Also adopts manifest-less installs
+    // whose content matches the current templates.
+    const manifestOut = {
+        version: getOwnPackage().version,
+        files: Object.fromEntries(pieces.map((p) => [p.key, sha256(p.content)])),
+    };
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(join(skillDir, MANIFEST_FILENAME), `${JSON.stringify(manifestOut, null, 2)}\n`, "utf-8");
     return {
         installedPath: skillPath,
-        installed: skillResult.installed,
-        overwrote: skillResult.overwrote,
-        companions: {
-            agentPath,
-            workflowPath,
-        },
+        installed: skillPiece.state !== "current",
+        overwrote: skillPiece.state === "stock" || skillPiece.state === "modified",
+        companions,
     };
 }
 //# sourceMappingURL=skill-install.js.map

package/dist/codebase-to-spec/version-check.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Fail-soft check for a newer published CLI version (CTS-PACK-4).
+ *
+ * The skill bundle pins the CLI version it was installed with
+ * (CTSO-INSTALL-5), so a long-lived install would otherwise run stale
+ * forever without noticing. Pack — the first deterministic step of every
+ * run — surfaces staleness so the skill can offer a refresh (CTSO-CONV-7).
+ *
+ * Any failure (offline, slow or unreachable registry, malformed response)
+ * yields `undefined`: the check must never fail or delay the pack beyond a
+ * short timeout.
+ */
+export interface VersionCheckResult {
+    current: string;
+    latest: string;
+    stale: boolean;
+}
+export declare const DEFAULT_VERSION_CHECK_TIMEOUT_MS = 2000;
+/**
+ * True when `latest` is a strictly newer release than `current`, comparing
+ * numeric segments. Prerelease suffixes are ignored; when the numeric
+ * segments tie, the versions are treated as equal (not stale).
+ */
+export declare function isNewerVersion(latest: string, current: string): boolean;
+export interface VersionCheckOptions {
+    timeoutMs?: number;
+    /** Injectable for tests. */
+    fetchImpl?: typeof fetch;
+}
+export declare function checkForNewerVersion(options?: VersionCheckOptions): Promise<VersionCheckResult | undefined>;
+//# sourceMappingURL=version-check.d.ts.map

package/dist/codebase-to-spec/version-check.js

@@ -0,0 +1,56 @@
+/**
+ * Fail-soft check for a newer published CLI version (CTS-PACK-4).
+ *
+ * The skill bundle pins the CLI version it was installed with
+ * (CTSO-INSTALL-5), so a long-lived install would otherwise run stale
+ * forever without noticing. Pack — the first deterministic step of every
+ * run — surfaces staleness so the skill can offer a refresh (CTSO-CONV-7).
+ *
+ * Any failure (offline, slow or unreachable registry, malformed response)
+ * yields `undefined`: the check must never fail or delay the pack beyond a
+ * short timeout.
+ */
+import { getOwnPackage } from "../utils/own-package.js";
+export const DEFAULT_VERSION_CHECK_TIMEOUT_MS = 2_000;
+/**
+ * True when `latest` is a strictly newer release than `current`, comparing
+ * numeric segments. Prerelease suffixes are ignored; when the numeric
+ * segments tie, the versions are treated as equal (not stale).
+ */
+export function isNewerVersion(latest, current) {
+    const parse = (v) => v
+        .split("-")[0]
+        .split(".")
+        .map((seg) => Number.parseInt(seg, 10) || 0);
+    const a = parse(latest);
+    const b = parse(current);
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        const diff = (a[i] ?? 0) - (b[i] ?? 0);
+        if (diff !== 0)
+            return diff > 0;
+    }
+    return false;
+}
+export async function checkForNewerVersion(options = {}) {
+    try {
+        const { name, version } = getOwnPackage();
+        const fetchImpl = options.fetchImpl ?? fetch;
+        const response = await fetchImpl(`https://registry.npmjs.org/${encodeURIComponent(name)}/latest`, {
+            signal: AbortSignal.timeout(options.timeoutMs ?? DEFAULT_VERSION_CHECK_TIMEOUT_MS),
+        });
+        if (!response.ok)
+            return undefined;
+        const body = (await response.json());
+        if (typeof body.version !== "string")
+            return undefined;
+        return {
+            current: version,
+            latest: body.version,
+            stale: isNewerVersion(body.version, version),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=version-check.js.map

package/dist/commands/ai-setup.d.ts

@@ -1,5 +1,16 @@
+/**
+ * Assistant identifiers accepted by the non-interactive --assistant flag
+ * (AISETUP-1). "other" is interactive-only: it prompts for a custom path.
+ */
+export declare const SUPPORTED_ASSISTANTS: readonly ["claude-code", "claude-desktop", "cursor", "antigravity", "codex", "github-copilot"];
+export interface AiSetupOptions {
+    assistant?: string;
+}
 /**
  * AI setup command - configures the MCP server for AI assistants
+ *
+ * AISETUP-1: with --assistant <id>, setup runs without any interactive prompt
+ * (an AI assistant configuring itself knows which assistant it is).
  */
-export declare function aiSetupCommand(): Promise<void>;
+export declare function aiSetupCommand(options?: AiSetupOptions): Promise<void>;
 //# sourceMappingURL=ai-setup.d.ts.map

package/dist/commands/ai-setup.js

@@ -13,9 +13,11 @@ function loadContextFileSection() {
     return loadTemplate("context-file-section.md");
 }
 /**
- * Install workflow guidance to the appropriate context file for a platform
+ * Install workflow guidance to the appropriate context file for a platform.
+ * With `yes` (the non-interactive --assistant path, AISETUP-1.0), both
+ * confirmations are auto-accepted — matching their interactive defaults.
  */
-async function installContextFileSection(platform) {
+async function installContextFileSection(platform, yes = false) {
     const fileName = getContextFileName(platform);
     if (!fileName) {
         console.error(`\n❌ Unknown platform: ${platform}`);
@@ -37,24 +39,26 @@ async function installContextFileSection(platform) {
             existingSection = section.content;
         }
     }
-    // Prompt user
+    // Prompt user (auto-accepted in non-interactive mode)
     const action = existingSection
         ? "Update"
         : existsSync(contextFilePath)
             ? "Add to"
             : "Create";
-    const response = await prompts({
-        type: "confirm",
-        name: "install",
-        message: `${action} ${fileName} with dotrequirements workflow guidance?`,
-        initial: true,
-    });
-    if (!response.install) {
-        console.log("");
-        return;
+    if (!yes) {
+        const response = await prompts({
+            type: "confirm",
+            name: "install",
+            message: `${action} ${fileName} with dotrequirements workflow guidance?`,
+            initial: true,
+        });
+        if (!response.install) {
+            console.log("");
+            return;
+        }
     }
-    // If updating, show what will change
-    if (existingSection) {
+    // If updating, show what will change (auto-accepted in non-interactive mode)
+    if (existingSection && !yes) {
         const confirmUpdate = await prompts({
             type: "confirm",
             name: "confirm",
@@ -80,12 +84,37 @@ async function installContextFileSection(platform) {
         console.log(`   Error: ${error instanceof Error ? error.message : String(error)}\n`);
     }
 }
+/**
+ * Assistant identifiers accepted by the non-interactive --assistant flag
+ * (AISETUP-1). "other" is interactive-only: it prompts for a custom path.
+ */
+export const SUPPORTED_ASSISTANTS = [
+    "claude-code",
+    "claude-desktop",
+    "cursor",
+    "antigravity",
+    "codex",
+    "github-copilot",
+];
 /**
  * AI setup command - configures the MCP server for AI assistants
+ *
+ * AISETUP-1: with --assistant <id>, setup runs without any interactive prompt
+ * (an AI assistant configuring itself knows which assistant it is).
  */
-export async function aiSetupCommand() {
+export async function aiSetupCommand(options = {}) {
     console.log(`🔧 Setting up ${brand} MCP server\n`);
-    // Interactive client selector
+    if (options.assistant) {
+        const id = options.assistant.toLowerCase();
+        if (!SUPPORTED_ASSISTANTS.includes(id)) {
+            // AISETUP-1.1: unsupported value → error listing supported identifiers
+            throw new Error(`Unsupported assistant "${options.assistant}". Supported: ${SUPPORTED_ASSISTANTS.join(", ")}`);
+        }
+        // AISETUP-1.0: no prompt; same setup path as the interactive selector
+        await dispatchSetup(id, true);
+        return;
+    }
+    // AISETUP-1.2: no flag → interactive selector, unchanged
     const response = await prompts({
         type: "select",
         name: "client",
@@ -105,34 +134,37 @@ export async function aiSetupCommand() {
         console.log("\nSetup cancelled.");
         return;
     }
-    switch (response.client) {
+    await dispatchSetup(response.client);
+}
+async function dispatchSetup(client, yes = false) {
+    switch (client) {
         case "claude-code":
-            await setupClaudeCode();
+            await setupClaudeCode(yes);
             break;
         case "claude-desktop":
             await setupClaudeDesktop();
             break;
         case "cursor":
-            await setupCursor();
+            await setupCursor(yes);
             break;
         case "antigravity":
-            await setupAntigravity();
+            await setupAntigravity(yes);
             break;
         case "codex":
-            await setupCodex();
+            await setupCodex(yes);
             break;
         case "github-copilot":
-            await setupGitHubCopilot();
+            await setupGitHubCopilot(yes);
             break;
         case "other":
             await setupOther();
             break;
         default:
-            console.log(`\n❌ ${response.client} is not yet supported.`);
+            console.log(`\n❌ ${client} is not yet supported.`);
             console.log("Please refer to the documentation for manual setup.");
     }
 }
-async function setupClaudeCode() {
+async function setupClaudeCode(yes = false) {
     console.log("\n📦 Configuring MCP for Claude Code...\n");
     const command = `claude mcp add-json dotrequirements '{"type":"stdio","command":"npx","args":["-y","@popoverai/dotrequirements","mcp"]}'`;
     let mcpConfigured = false;
@@ -162,7 +194,7 @@ async function setupClaudeCode() {
     if (mcpConfigured) {
         console.log("\n⚠️  Important: Restart Claude Code for changes to take effect.");
         console.log("\nYou can now ask your AI assistant to help write requirements!\n");
-        await installContextFileSection("claude-code");
+        await installContextFileSection("claude-code", yes);
     }
 }
 async function setupClaudeDesktop() {
@@ -237,7 +269,7 @@ async function setupClaudeDesktop() {
         console.log(JSON.stringify(manualConfig, null, 2));
     }
 }
-async function setupCursor() {
+async function setupCursor(yes = false) {
     console.log("\n📦 Configuring MCP for Cursor (project-specific)...\n");
     const configPath = join(process.cwd(), ".cursor", "mcp.json");
     const configDir = join(process.cwd(), ".cursor");
@@ -272,7 +304,7 @@ async function setupCursor() {
         console.log(`   Config file: ${configPath}\n`);
         console.log("⚠️  Important: Reload or restart Cursor for changes to take effect.");
         console.log("\nYou can now ask your AI assistant to help write requirements!\n");
-        await installContextFileSection("cursor");
+        await installContextFileSection("cursor", yes);
     }
     catch (error) {
         console.error("❌ Failed to configure MCP automatically.");
@@ -288,7 +320,7 @@ async function setupCursor() {
         console.log(JSON.stringify(manualConfig, null, 2));
     }
 }
-async function setupAntigravity() {
+async function setupAntigravity(yes = false) {
     console.log("\n📦 Configuring MCP for Google Antigravity...\n");
     const configPath = join(homedir(), ".gemini", "antigravity", "mcp_config.json");
     const configDir = join(homedir(), ".gemini", "antigravity");
@@ -367,7 +399,7 @@ async function setupAntigravity() {
         else {
             console.log("");
         }
-        await installContextFileSection("antigravity");
+        await installContextFileSection("antigravity", yes);
     }
     catch (error) {
         console.error("❌ Failed to configure MCP automatically.");
@@ -376,7 +408,7 @@ async function setupAntigravity() {
         console.log(`  ${configPath}`);
     }
 }
-async function setupCodex() {
+async function setupCodex(yes = false) {
     console.log("\n📦 Configuring MCP for OpenAI Codex...\n");
     const command = `codex mcp add dotrequirements -- npx -y @popoverai/dotrequirements mcp`;
     try {
@@ -384,7 +416,7 @@ async function setupCodex() {
         console.log("\n✅ MCP configured successfully for Codex!");
         console.log("\n⚠️  Important: Restart Codex for changes to take effect.");
         console.log("\nYou can now ask your AI assistant to help write requirements!\n");
-        await installContextFileSection("codex");
+        await installContextFileSection("codex", yes);
     }
     catch {
         console.error("\n❌ Failed to configure MCP automatically.");
@@ -396,12 +428,12 @@ async function setupCodex() {
         console.log('args = ["-y", "@popoverai/dotrequirements", "mcp"]');
     }
 }
-async function setupGitHubCopilot() {
+async function setupGitHubCopilot(yes = false) {
     console.log("\n📦 Configuring skills for GitHub Copilot...\n");
     console.log("ℹ️  GitHub Copilot discovers MCP servers from your IDE configuration.");
     console.log("   Please configure the MCP server in VS Code settings or GitHub settings.\n");
     console.log("   MCP server command: npx -y @popoverai/dotrequirements mcp\n");
-    await installContextFileSection("github-copilot");
+    await installContextFileSection("github-copilot", yes);
 }
 async function setupOther() {
     console.log("\n📦 Custom Context File Setup\n");