@counterfact-labs/cli 0.2.6 → 0.2.7

package/dist/cli/main.js

@@ -2,7 +2,7 @@
 import { pathToFileURL } from "node:url";
 import { realpath } from "node:fs/promises";
 import { errorCode, errorText } from "./api.js";
-import { readEmailSignIn } from "../adapters/settings.js";
+import { readEmailSignIn, readSelectionSettings, scopeChoicesEnabled } from "../adapters/settings.js";
 import { commandContext } from "./context.js";
 import { analyze, parseAnalyzeOptions } from "./commands/analyze.js";
 import { finding } from "./commands/finding.js";
@@ -10,26 +10,38 @@ import { balance } from "./commands/balance.js";
 import { login, parseLoginOptions } from "./commands/login.js";
 import { logout } from "./commands/logout.js";
 import { serveMcp } from "./mcp.js";
+import { loadAnalysisScope } from "./scope-choices.js";
+import { FILE_SCOPE_PUBLIC_USAGE } from "../contract/scope-choice.js";
 const usage = "Usage: counterfact-labs analyze [path] [--proposal <json-file>]\n       counterfact-labs finding <id>\n       counterfact-labs balance | login | logout | mcp\n";
 export async function run(args, options = {}) {
     const write = options.write ?? (text => { process.stdout.write(text); });
     const emailSignIn = options.emailSignIn ?? readEmailSignIn(options.env);
-    const commandOptions = { ...options, emailSignIn };
     try {
         const [command, ...rest] = args;
+        const env = options.startup?.settings ?? options.env ?? process.env;
+        // Help follows the CLI defaults without validating unrelated commands' analysis switches.
+        const selectionSettings = readSelectionSettings(env, { validate: command === "analyze" || command === "mcp" });
+        const commandOptions = { ...options, emailSignIn, env: { ...(options.env ?? process.env), ...selectionSettings,
+                ...(command === "analyze" || command === "mcp" ? {} : {
+                    CF_FILE_SCOPE: undefined, CF_SCOPE_CHOICES: undefined, CF_LOCAL_IMPORT_RESOLUTION: undefined,
+                }) } };
+        const choices = scopeChoicesEnabled(selectionSettings);
+        const commandUsage = choices ? FILE_SCOPE_PUBLIC_USAGE : usage;
         if (["--help", "-h", "help"].includes(command) || !command) {
-            write(usage);
+            write(commandUsage);
             return 0;
         }
         if (command === "analyze") {
             let parsed;
             try {
-                parsed = parseAnalyzeOptions(rest);
+                parsed = parseAnalyzeOptions(rest, choices);
             }
             catch {
-                throw new Error(usage.trimEnd());
+                throw new Error(commandUsage.trimEnd());
             }
-            return await analyze(parsed.path, parsed.options, commandContext(commandOptions));
+            const ctx = commandContext(commandOptions);
+            const scope = await loadAnalysisScope(parsed.options, ctx.cwd ?? process.cwd(), ctx.startup.settings);
+            return await analyze(parsed.path, { ...parsed.options, scope }, ctx);
         }
         if (command === "finding" && rest.length === 1 && !rest[0].startsWith("-"))
             return await finding(rest[0], commandContext(commandOptions));
@@ -39,12 +51,12 @@ export async function run(args, options = {}) {
                 parsed = parseLoginOptions(rest);
             }
             catch {
-                throw new Error(usage.trimEnd());
+                throw new Error(commandUsage.trimEnd());
             }
             return await login(commandContext(commandOptions), parsed);
         }
         if (rest.length)
-            throw new Error(usage.trimEnd());
+            throw new Error(commandUsage.trimEnd());
         if (command === "balance")
             return await balance(commandContext(commandOptions));
         if (command === "login")
@@ -55,7 +67,7 @@ export async function run(args, options = {}) {
             await serveMcp(process.stdin, process.stdout, options);
             return 0;
         }
-        throw new Error(usage.trimEnd());
+        throw new Error(commandUsage.trimEnd());
     }
     catch (error) {
         write(errorText(error) + "\n");

package/dist/cli/mcp.js

@@ -21,6 +21,34 @@ import { fixRequestTools, waitingFixes, waitingFixCount, claimFix, FIX_DISCOVERY
 import { FINDING_PROJECT_MESSAGE, FindingReferences, numberedFindingInputSchema } from "./finding-lookup.js";
 import { findingDisplayRows, formatFindingNumber, formatWaitingFixes } from "./finding-display.js";
 import { readFindingSettings } from "./finding-settings.js";
+import { z } from "zod";
+import { readCliSettings, readSelectionSettings, selectionModeEnabled, scopeChoicesEnabled } from "../adapters/settings.js";
+import { resolveAnalysisSelection } from "./analysis-selection.js";
+import { analysisScopeSchema, chooseScopeMcpResultSchema } from "../contract/scope-choice.js";
+import { scopeChoiceRefusal } from "../contract/selection-offer.js";
+import { loadAnalysisScope, scopeChoiceText } from "./scope-choices.js";
+const fileAnalysisDescription = "Analyze an agent folder or one agent file on this computer. For a file, Counterfact reads that file and the project files it imports inside the launch folder. Each call that runs an analysis charges the user's balance unless a free analysis is available, so call it only when the user asks for an analysis. A free first analysis needs no top-up. After edits, suggest an analysis and wait for the user to ask.";
+const scopeChoiceDescription = "If Counterfact returns scope choices, show what each includes and ask the user to choose before calling again with that scope, unless the user already chose it. Do not run all choices automatically.";
+const fileAnalysisEnding = "Prices are listed on the top-up page and website. If the balance doesn't cover the analysis, show the returned message and top-up link.";
+const filePathDescription = "The agent folder or agent file on this computer, inside the launch folder.";
+const fileScopeDescription = "Optional: a scope returned by Counterfact, using the same snapshot and selected file. Include all imports, no imports, or the listed imports chosen by the user.";
+const fileProposalDescription = "Optional: the files you believe make up the agent, with each file's role. For a folder, paths are relative to that folder. For a file, paths are relative to the launch folder and must belong to the selected file's import scope.";
+const fileProposalPathDescription = "Paths are relative to the selected folder, or to the launch folder when selecting a file.";
+function fileAnalysisTool(choices) {
+    const proposal = structuredClone(agentProposalInputSchema);
+    if (typeof proposal.properties?.files === "object" && proposal.properties.files && "items" in proposal.properties.files) {
+        const files = proposal.properties.files.items;
+        if (files && !Array.isArray(files) && typeof files === "object" && typeof files.properties?.path === "object")
+            files.properties.path.description = fileProposalPathDescription;
+    }
+    const scope = z.toJSONSchema(analysisScopeSchema);
+    delete scope.$schema;
+    return { name: ANALYZE_TOOL_NAME,
+        description: [fileAnalysisDescription, ...(choices ? [scopeChoiceDescription] : []), fileAnalysisEnding].join(" "),
+        inputSchema: { type: "object", properties: { path: { type: "string", description: filePathDescription },
+                proposal: { ...proposal, description: fileProposalDescription }, ...(choices ? { scope: { ...scope, description: fileScopeDescription } } : {}) },
+            required: ["path"], additionalProperties: false } };
+}
 const legacyTools = [
     {
         name: ANALYZE_TOOL_NAME,
@@ -48,9 +76,15 @@ export async function serveMcp(input, output, options = {}) {
     const launch = guarded ? resolveFolderPath(cwd).catch(() => null) : Promise.resolve(cwd);
     const lastAnalysis = new Map();
     const findingSettings = readFindingSettings(options.env);
+    const analysisSwitches = readSelectionSettings(options.startup?.settings ?? options.env ?? process.env);
+    const choicesEnabled = scopeChoicesEnabled(analysisSwitches);
+    const selectionEnabled = selectionModeEnabled(analysisSwitches);
+    const analysisEnv = selectionEnabled ? { ...(options.env ?? process.env), ...analysisSwitches } : undefined;
+    let analysisStartup = options.startup;
     const { numbersEnabled, fixesEnabled } = findingSettings;
     const references = new FindingReferences();
-    const emailSignIn = options.emailSignIn ?? readEmailSignIn(options.env);
+    const emailEnv = analysisEnv && Object.hasOwn(analysisEnv, "CF_EMAIL_SIGN_IN") ? analysisEnv : options.env;
+    const emailSignIn = options.emailSignIn ?? readEmailSignIn(emailEnv);
     const signInTools = emailSignIn ? [...legacyTools.slice(0, 3),
         {
             name: "sign_in_status",
@@ -76,7 +110,7 @@ export async function serveMcp(input, output, options = {}) {
                 }, required: ["email", "code"], additionalProperties: false },
         },
     ] : legacyTools;
-    const tools = signInTools.map(tool => tool.name === "get_finding" && numbersEnabled ? {
+    const tools = signInTools.map(tool => tool.name === ANALYZE_TOOL_NAME && selectionEnabled ? fileAnalysisTool(choicesEnabled) : tool).map(tool => tool.name === "get_finding" && numbersEnabled ? {
         ...tool, inputSchema: numberedFindingInputSchema,
     } : tool).concat(fixesEnabled ? fixRequestTools : []);
     let pendingSignIn;
@@ -91,7 +125,7 @@ export async function serveMcp(input, output, options = {}) {
         if (!object(args))
             throw new ProtocolError(-32602, "Tool arguments must be an object.");
         const name = params.name;
-        const allowed = name === ANALYZE_TOOL_NAME ? ["path", "proposal"] : name === "get_finding" ? (numbersEnabled ? Object.keys(numberedFindingInputSchema.properties) : ["id"])
+        const allowed = name === ANALYZE_TOOL_NAME ? ["path", "proposal", ...(choicesEnabled ? ["scope"] : [])] : name === "get_finding" ? (numbersEnabled ? Object.keys(numberedFindingInputSchema.properties) : ["id"])
             : name === "claim_fix" ? ["id"]
                 : name === "sign_in_status" ? (emailSignIn ? ["wait", "path"] : ["wait"])
                     : emailSignIn && name === "sign_in" ? ["email"] : emailSignIn && name === "sign_in_with_code" ? ["email", "code"] : [];
@@ -117,6 +151,7 @@ export async function serveMcp(input, output, options = {}) {
         let reason;
         let freeAnalysisAvailable = false;
         let agentChoice;
+        let scopeChoice;
         let findingIds;
         let findings, projectId;
         let loadedFinding;
@@ -126,13 +161,22 @@ export async function serveMcp(input, output, options = {}) {
         let started = false;
         let signIn;
         try {
-            const ctx = commandContext({ ...options, env: { ...(options.env ?? process.env), CF_FINDING_AUDIENCE: audienceChoice },
+            // Listing tools must not validate settings used only when a tool runs.
+            if (selectionEnabled)
+                analysisStartup ??= readCliSettings(analysisEnv, emailSignIn);
+            const analysisSettings = analysisStartup?.settings ?? {};
+            const ctx = commandContext({ ...options, ...(analysisStartup ? { startup: analysisStartup } : {}), env: { ...(analysisEnv ?? options.env ?? process.env), ...analysisSwitches, CF_FINDING_AUDIENCE: audienceChoice },
                 onCheckFailure: failure => { reason = failure.reason; options.onCheckFailure?.(failure); },
                 emailSignIn, findingSettings, signal, onCheckStart: () => {
                     started = true;
                     if (guarded && analysisFolder)
                         lastAnalysis.set(analysisFolder, ctx.now());
                     options.onCheckStart?.();
+                }, onScopeChoice: choice => {
+                    scopeChoice = choice;
+                    if (guarded && analysisFolder)
+                        lastAnalysis.delete(analysisFolder);
+                    options.onScopeChoice?.(choice);
                 }, onAgentChoice: choice => { agentChoice = choice; options.onAgentChoice?.(choice); }, onCheckComplete: result => {
                     findingIds = result.findingIds ?? [];
                     if (numbersEnabled) {
@@ -244,7 +288,7 @@ export async function serveMcp(input, output, options = {}) {
                         signal.addEventListener("abort", cancel, { once: true });
                         try {
                             signal.throwIfAborted();
-                            const flow = await startSignIn(commandContext({ ...options, emailSignIn, findingSettings, homeDir: ctx.homeDir, baseUrl: ctx.api.baseUrl, signal: controller.signal }));
+                            const flow = await startSignIn(commandContext({ ...options, startup: ctx.startup, emailSignIn, findingSettings, homeDir: ctx.homeDir, baseUrl: ctx.api.baseUrl, signal: controller.signal }));
                             pending = { flow, controller, opened: false };
                             pendingSignIn = pending;
                             signInFailure = undefined;
@@ -272,18 +316,25 @@ export async function serveMcp(input, output, options = {}) {
                 const launchFolder = await launch;
                 if (guarded && !launchFolder)
                     throw new CliRefusalError("launch_folder_unavailable");
-                const folder = guarded ? await resolveMcpAgentFolder(args.path, launchFolder, ctx.homeDir) : resolveAgentFolder(args.path, cwd);
-                const last = lastAnalysis.get(folder);
+                const scope = await loadAnalysisScope({ scope: args.scope }, cwd, analysisSettings);
+                const selection = selectionEnabled ? await resolveAnalysisSelection(args.path, launchFolder ?? cwd, analysisSettings, scope) : undefined;
+                if (guarded && selection?.kind === "folder")
+                    await resolveMcpAgentFolder(selection.path, launchFolder, ctx.homeDir);
+                const folder = selection?.path ?? (guarded ? await resolveMcpAgentFolder(args.path, launchFolder, ctx.homeDir) : resolveAgentFolder(args.path, cwd));
+                const key = selection ? JSON.stringify([selection.launchRoot, selection.path]) : folder;
+                const last = lastAnalysis.get(key);
                 if (guarded && last !== undefined && ctx.now() - last < 10 * 60 * 1000) {
                     throw new CliRefusalError("repeat_too_soon");
                 }
-                analysisFolder = folder;
+                analysisFolder = key;
                 try {
-                    exitCode = await analyze(folder, { proposal: args.proposal }, ctx);
+                    exitCode = await analyze(folder, { proposal: args.proposal, scope, selection }, ctx);
                 }
                 finally {
-                    if (guarded && started)
-                        lastAnalysis.set(folder, ctx.now());
+                    if (reason === "results_pending")
+                        lastAnalysis.delete(key);
+                    else if (guarded && started && !scopeChoice)
+                        lastAnalysis.set(key, ctx.now());
                 }
             }
         }
@@ -293,6 +344,14 @@ export async function serveMcp(input, output, options = {}) {
             reason = failure.reason;
             exitCode = errorCode(error);
         }
+        if (scopeChoice) {
+            const refusal = scopeChoiceRefusal(scopeChoice);
+            if (!refusal)
+                return chooseScopeMcpResultSchema.parse({ content: [{ type: "text", text: scopeChoiceText(scopeChoice) }], isError: false,
+                    structuredContent: { ...scopeChoice, exitCode: 0 } });
+            text = refusal + "\n";
+            exitCode = 1;
+        }
         // Some clients (Claude Code among them) give the model only the structured result when one is present, so it
         // repeats the text: without it the model cannot read the result.
         return { content: [{ type: "text", text }], isError: exitCode !== 0,

package/dist/cli/prior-completion.js

@@ -0,0 +1,35 @@
+import { discardCompletion, loadCompletions, matchesCompletionSetup } from "../adapters/completion.js";
+import { completionRecoveryDecision } from "./completion-recovery.js";
+export class CompletionSettingsMismatchError extends Error {
+    reason = "completion_settings_mismatch";
+}
+/** Leave other setups alone before the runner assigns any reservation or recovery state. */
+export async function priorCompletion(folder, options) {
+    const records = await loadCompletions(folder, { retainUnsaved: options.retryEnabled,
+        consoleOrigin: options.consoleOrigin, projectId: options.projectId, identity: options.identity });
+    const notices = new Set();
+    let prior;
+    for (const item of records) {
+        const { record } = item;
+        if ((record.uploaded || record.finished) && !options.retryUpload)
+            continue;
+        const localMismatch = !matchesCompletionSetup(record, options);
+        const decision = completionRecoveryDecision({ retryEnabled: options.retryEnabled, payload: record.payload,
+            localMismatch, timing: { completedAt: record.completedAt, absoluteExpiresAt: record.absoluteExpiresAt },
+            now: (options.now ?? Date.now)(), statusLookup: { kind: "skipped" }, uploadOutcome: { kind: record.uploaded ? "saved" : "pending" } });
+        if (decision.action === "leave") {
+            notices.add(decision.message);
+            continue;
+        }
+        if (localMismatch && decision.action === "give-up") {
+            await discardCompletion(folder, item.path, options.identity);
+            if (decision.message)
+                notices.add(decision.message);
+            continue;
+        }
+        if (localMismatch)
+            throw new CompletionSettingsMismatchError("message" in decision ? decision.message : undefined);
+        prior ??= item;
+    }
+    return { prior, notices: [...notices] };
+}