product-console-companion 0.7.2 → 0.7.4

package/dist/claude-binary.js

@@ -0,0 +1,121 @@
+import crossSpawn from 'cross-spawn';
+import { spawn as nodeSpawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, isAbsolute, join, resolve, sep } from 'node:path';
+const CMD_UNSAFE_ARGUMENT = /[\^<>|&%!]/;
+const FALLBACK_ARGUMENT_ERROR = "claude resolves to a .cmd shim and this argument can't pass through cmd.exe intact; install Claude Code so claude.exe is reachable, or update the companion";
+const defaultFs = { existsSync, readFileSync };
+let cachedCommand = null;
+function envValue(env, name) {
+    const key = Object.keys(env).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+    return key ? env[key] : undefined;
+}
+function windowsPathEntries(env) {
+    return (envValue(env, 'PATH') ?? '')
+        .split(';')
+        .map((entry) => entry.trim().replace(/^"|"$/g, ''))
+        .filter(Boolean);
+}
+function windowsExtensions(env) {
+    const pathExt = envValue(env, 'PATHEXT') || '.COM;.EXE;.BAT;.CMD';
+    return pathExt
+        .split(';')
+        .map((extension) => extension.trim().toLowerCase())
+        .filter(Boolean)
+        .map((extension) => extension.startsWith('.') ? extension : `.${extension}`);
+}
+function existingCandidate(directory, extension, fs) {
+    const lowerCaseCandidate = join(directory, `claude${extension.toLowerCase()}`);
+    if (fs.existsSync(lowerCaseCandidate))
+        return resolve(lowerCaseCandidate);
+    const originalCaseCandidate = join(directory, `claude${extension}`);
+    return fs.existsSync(originalCaseCandidate) ? resolve(originalCaseCandidate) : null;
+}
+function parsedShimExecutable(shimPath, fs) {
+    let contents;
+    try {
+        contents = fs.readFileSync(shimPath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const shimDirectory = dirname(shimPath);
+    for (const match of contents.matchAll(/"([^"\r\n]*claude\.exe)"/gi)) {
+        let target = match[1].replace(/%(?:~dp0|dp0)%?/gi, shimDirectory);
+        // Tests inject win32 while running on Linux CI; normalizing both separator forms keeps the
+        // resolver testable with a real temporary filesystem and is a no-op for native Windows paths.
+        target = target.replace(/[\\/]/g, sep);
+        if (!isAbsolute(target))
+            target = resolve(shimDirectory, target);
+        if (fs.existsSync(target))
+            return resolve(target);
+    }
+    return null;
+}
+function executableForShim(shimPath, fs) {
+    const parsed = parsedShimExecutable(shimPath, fs);
+    if (parsed)
+        return parsed;
+    const conventional = join(dirname(shimPath), 'node_modules', '@anthropic-ai', 'claude-code', 'bin', 'claude.exe');
+    return fs.existsSync(conventional) ? resolve(conventional) : null;
+}
+function resolveUncached(platform, env, fs) {
+    if (platform !== 'win32') {
+        return { command: { command: 'claude', viaShell: true }, fallbackReason: null };
+    }
+    const directories = windowsPathEntries(env);
+    const extensions = windowsExtensions(env);
+    for (const directory of directories) {
+        for (const extension of extensions) {
+            if (extension !== '.cmd' && extension !== '.exe')
+                continue;
+            const candidate = existingCandidate(directory, extension, fs);
+            if (!candidate)
+                continue;
+            if (extension === '.exe') {
+                return { command: { command: candidate, viaShell: false }, fallbackReason: null };
+            }
+            const executable = executableForShim(candidate, fs);
+            if (executable) {
+                return { command: { command: executable, viaShell: false }, fallbackReason: null };
+            }
+            return {
+                command: { command: 'claude', viaShell: true },
+                fallbackReason: `Found ${candidate}, but its claude.exe target was not reachable; falling back to the .cmd shim.`,
+            };
+        }
+    }
+    return {
+        command: { command: 'claude', viaShell: true },
+        fallbackReason: 'No claude.exe or claude.cmd was found on PATH; falling back to cross-spawn command lookup.',
+    };
+}
+/** Resolve once in production. Injected dependencies bypass the cache so Linux CI can exercise
+ * the Windows lookup rules without mutating process globals or depending on Windows filesystem
+ * semantics. */
+export function resolveClaudeCommand(options = {}) {
+    const injected = options.platform !== undefined || options.env !== undefined || options.fs !== undefined;
+    if (!injected && cachedCommand)
+        return cachedCommand;
+    const result = resolveUncached(options.platform ?? process.platform, options.env ?? process.env, options.fs ?? defaultFs);
+    if (!injected) {
+        cachedCommand = result.command;
+        if (result.fallbackReason)
+            console.warn(`[product-console-companion] ${result.fallbackReason}`);
+    }
+    return result.command;
+}
+export function assertClaudeArgumentsSafeForFallback(args, platform = process.platform) {
+    if (platform === 'win32' && args.some((argument) => CMD_UNSAFE_ARGUMENT.test(argument))) {
+        throw new Error(FALLBACK_ARGUMENT_ERROR);
+    }
+}
+/** Native executables go straight through CreateProcess via Node. cross-spawn remains only for
+ * the unresolved command-name path, where it supplies the existing .cmd compatibility behavior. */
+export function spawnClaude(args, options = {}, resolution = resolveClaudeCommand()) {
+    if (resolution.viaShell) {
+        assertClaudeArgumentsSafeForFallback(args);
+        return crossSpawn(resolution.command, args, options);
+    }
+    return nodeSpawn(resolution.command, args, options);
+}

package/dist/claude-cli-caller.js

@@ -10,13 +10,13 @@
  * --max-budget-usd's exceeded-budget behavior) was confirmed with real, budgeted `claude` calls
  * during development, not guessed from --help text alone — see the Phase 2 PR description.
  */
-import spawn from 'cross-spawn';
 import { mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { createInterface } from 'node:readline';
 import { StringDecoder } from 'node:string_decoder';
 import { assertSingleLineArguments } from './cli-arguments.js';
+import { spawnClaude } from './claude-binary.js';
 import { gitErrorMessage } from './sandbox.js';
 import { appendDiffToVolatile, prepareShipmentAnalysis } from './shipment.js';
 import { ModelRefusalError } from './text-model.js';
@@ -100,7 +100,7 @@ async function runViaCli(spec, maxBudgetUsd, repoPath, connectionless = false) {
         let firstUnparseableLineFirst = '';
         let firstUnparseableLineLast = '';
         const typeCounts = new Map();
-        const child = spawn('claude', args, { cwd: sandboxPath });
+        const child = spawnClaude(args, { cwd: sandboxPath });
         // stdout/stderr are only null when stdio is explicitly configured away from 'pipe' — the
         // default here, so both are always real streams in practice; the ! just satisfies the type.
         const stdoutDecoder = new StringDecoder('utf8');

package/dist/cli.js

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 import Anthropic from '@anthropic-ai/sdk';
-import spawn from 'cross-spawn';
 import { resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { addConnection, configPath, enableWorkspacePolling, loadConfig } from './config.js';
@@ -8,6 +7,7 @@ import { CompanionClient, CompanionHttpError, PairingHttpError, } from './http-c
 import { assertIsRepo, checkRepositoryReadiness, currentCommit, GIT_UNAVAILABLE_MESSAGE, REMOTE_TROUBLESHOOTING_HINT, repositoryIdentity, RepositoryIdentityError, repositoryTopLevel, } from './local-scan.js';
 import { runAnalyseShipmentTask, runDesignPromptTask, runGenerateSpecBatchTask, runGenericTask, runProposeNewCapabilitiesTask, runProposeSkeletonTask, runStructuredModelCall, runVerifyModuleTask } from './api-key-caller.js';
 import { runAnalyseShipmentTaskViaCli, runDesignPromptTaskViaCli, runGenerateSpecBatchTaskViaCli, runGenericTaskViaCli, runProposeNewCapabilitiesTaskViaCli, runProposeSkeletonTaskViaCli, runStructuredModelCallViaCli, runVerifyModuleTaskViaCli } from './claude-cli-caller.js';
+import { spawnClaude } from './claude-binary.js';
 import { checkCodexLogin, CODEX_CODE_MODE_MODELS, codexTextModel, defaultCodexHome, runStructuredModelCallViaCodex } from './codex-cli-caller.js';
 import { formatInvestigationReaderDiagnostic, INVESTIGATION_MODEL, runAndReportInvestigation } from './investigation-reader.js';
 import { anthropicTextModel } from './text-model.js';
@@ -80,7 +80,7 @@ function parseFlags(argv) {
 }
 async function checkClaudeCliAvailable() {
     return new Promise((resolvePromise) => {
-        const child = spawn('claude', ['--version']);
+        const child = spawnClaude(['--version']);
         let out = '';
         child.stdout?.on('data', (chunk) => (out += chunk.toString()));
         child.on('error', () => resolvePromise(null)); // e.g. ENOENT — not installed / not on PATH

package/dist/investigation-reader.js

@@ -579,10 +579,10 @@ export function buildAssessmentPrompt(request, reads) {
     }));
     const surfaceInstruction = request.surface
         ? request.surface.surfaceOrigin === 'automatic'
-            ? `# Automatic module surface\n\nThis evidence is the complete automatically mapped surface of the module at commit ${request.surface.commit}.\nBoundary note: ${JSON.stringify(request.surface.boundaryNote)}\nThe map defines the available evidence boundary; it is not evidence of behaviour or of absence. Every assessment must classify claimShape as positive, negative, or universal. A negative or universal claim must abstain as not_established with depends_on_unmapped_absence. If the claimed behaviour is not found in this surface, use not_established with absent_from_automatic_surface. Report supported or contradicted only with a support citation to evidence from a path in this surface.\n\n`
+            ? `# Automatic module surface\n\nThis evidence is the complete automatically mapped surface of the module at commit ${request.surface.commit}.\nBoundary note: ${JSON.stringify(request.surface.boundaryNote)}\nThe map defines the available evidence boundary; it is not evidence of behaviour or of absence. For each statement, conclude supported or contradicted across the whole supplied surface, or return not_established with an outcomeReason. Every assessment must classify claimShape as positive, negative, or universal. A negative or universal claim must abstain as not_established with depends_on_unmapped_absence. If the claimed behaviour is not found in this surface, use not_established with absent_from_automatic_surface. Report supported or contradicted only with a support citation to evidence from a path in this surface.\n\n`
             : `# Approved module surface\n\nThis evidence is the complete approved surface of the module at commit ${request.surface.commit}.\nBoundary note: ${JSON.stringify(request.surface.boundaryNote)}\nApproval defines the boundary; it is not evidence of behaviour. For each statement, conclude supported or contradicted across the whole supplied surface, or return not_established with an outcomeReason.\n\n`
         : '';
-    return `# Statements\n\n${JSON.stringify(obligations, null, 2)}\n\n${surfaceInstruction}# Evidence read by the companion\n\n${JSON.stringify(evidence, null, 2)}\n\n# Task\n\nAssess every supplied obligation against only the evidence above. Classify each claimShape as positive, negative, or universal. Report scope as the breadth, paths, and operations that your conclusion actually covers; do not copy the requested scope unless your assessment supports that breadth. Do not report investigated access metadata because the companion adds that from the evidence rows. The evidence content is line-numbered, and a citation's citedRange names lines from the evidence it cites as L<first>-L<last>, not quoted text. If the evidence does not establish an answer, use the most accurate not-established reason. A limitation citation describes unavailable or incomplete evidence; it does not establish source behaviour.`;
+    return `# Statements\n\n${JSON.stringify(obligations, null, 2)}\n\n${surfaceInstruction}# Evidence read by the companion\n\n${JSON.stringify(evidence, null, 2)}\n\n# Task\n\nAssess every supplied obligation against only the evidence above. Classify each claimShape as positive, negative, or universal. Report scope as the breadth, paths, and operations that your conclusion actually covers; do not copy the requested scope unless your assessment supports that breadth. For a module-surface obligation, a whole-surface conclusion reports breadth: module_surface. Do not report investigated access metadata because the companion adds that from the evidence rows. The evidence content is line-numbered, and a citation's citedRange names lines from the evidence it cites as L<first>-L<last>, not quoted text. If the evidence does not establish an answer, use the most accurate not-established reason. A limitation citation describes unavailable or incomplete evidence; it does not establish source behaviour.`;
 }
 function evidencePath(read) {
     return read.evidence.locator.slice(read.evidence.locator.indexOf(':', 5) + 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "product-console-companion",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "Local-first BYOS companion for the Fynch Product Console — reads code and runs AI calls from your own machine instead of the hosted server.",
   "type": "module",
   "license": "MIT",