@withtruing/companion 0.13.2 → 0.14.0

package/dist/schema-entities.js

@@ -36,12 +36,12 @@ export function validSchemaProbe(value) {
     }
     return new Set(probe.schemaPaths).size === probe.schemaPaths.length;
 }
-function runGit(repoPath, args, outputLimit = MAX_FILE_BYTES + 1) {
+function runGit(repoPath, args, outputLimit = MAX_FILE_BYTES + 1, environment) {
     return new Promise((resolve, reject) => {
         const child = spawn('git', ['--no-replace-objects', ...args], {
             cwd: repoPath,
             stdio: ['ignore', 'pipe', 'pipe'],
-            env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+            env: environment ?? { ...process.env, GIT_TERMINAL_PROMPT: '0' },
             windowsHide: true,
         });
         const chunks = [];
@@ -80,8 +80,8 @@ function runGit(repoPath, args, outputLimit = MAX_FILE_BYTES + 1) {
         }, GIT_TIMEOUT_MS);
     });
 }
-async function gitText(repoPath, revision, path) {
-    const output = await runGit(repoPath, ['show', `${revision}:${path}`]);
+async function gitText(repoPath, revision, path, environment) {
+    const output = await runGit(repoPath, ['show', `${revision}:${path}`], undefined, environment);
     if (output.exitCode !== 0)
         return null;
     if (output.stdout.includes(0))
@@ -93,8 +93,8 @@ async function gitText(repoPath, revision, path) {
         return null;
     }
 }
-async function gitPathExists(repoPath, revision, path) {
-    return (await runGit(repoPath, ['cat-file', '-e', `${revision}:${path}`], 100)).exitCode === 0;
+async function gitPathExists(repoPath, revision, path, environment) {
+    return (await runGit(repoPath, ['cat-file', '-e', `${revision}:${path}`], 100, environment)).exitCode === 0;
 }
 function skipTrivia(source, start) {
     let index = start;
@@ -617,14 +617,14 @@ function referencesEntity(facts, entity) {
     return entity.mappedName !== null
         && facts.strings.some((value) => value.includes(`"${entity.mappedName}"`));
 }
-async function headFile(repoPath, head, path) {
-    const size = await runGit(repoPath, ['cat-file', '-s', `${head}:${path}`], 100);
+async function headFile(repoPath, head, path, environment) {
+    const size = await runGit(repoPath, ['cat-file', '-s', `${head}:${path}`], 100, environment);
     if (size.exitCode !== 0)
         return null;
     const parsed = Number(size.stdout.toString('ascii').trim());
     if (!Number.isSafeInteger(parsed) || parsed < 0 || parsed > MAX_FILE_BYTES)
         return null;
-    return gitText(repoPath, head, path);
+    return gitText(repoPath, head, path, environment);
 }
 export async function detectSchemaImpact(input) {
     if (!validSchemaProbe(input.probe))
@@ -639,9 +639,9 @@ export async function detectSchemaImpact(input) {
         const headSchemas = [];
         const baseSchemas = [];
         for (const path of new Set([...input.probe.schemaPaths, ...changedSchemas])) {
-            const text = await gitText(input.repoPath, input.head, path);
+            const text = await gitText(input.repoPath, input.head, path, input.environment);
             if (text === null) {
-                if (await gitPathExists(input.repoPath, input.head, path)) {
+                if (await gitPathExists(input.repoPath, input.head, path, input.environment)) {
                     return { entities: null, modulesReferencing: [] };
                 }
                 continue;
@@ -653,12 +653,12 @@ export async function detectSchemaImpact(input) {
         }
         for (const path of changedSchemas) {
             const [beforeText, afterText] = await Promise.all([
-                gitText(input.repoPath, input.base, path),
-                gitText(input.repoPath, input.head, path),
+                gitText(input.repoPath, input.base, path, input.environment),
+                gitText(input.repoPath, input.head, path, input.environment),
             ]);
             const [beforeExists, afterExists] = await Promise.all([
-                beforeText === null ? gitPathExists(input.repoPath, input.base, path) : false,
-                afterText === null ? gitPathExists(input.repoPath, input.head, path) : false,
+                beforeText === null ? gitPathExists(input.repoPath, input.base, path, input.environment) : false,
+                afterText === null ? gitPathExists(input.repoPath, input.head, path, input.environment) : false,
             ]);
             if (beforeExists || afterExists)
                 return { entities: null, modulesReferencing: [] };
@@ -676,9 +676,9 @@ export async function detectSchemaImpact(input) {
             }
         }
         for (const path of changedMigrations) {
-            const sql = await gitText(input.repoPath, input.head, path);
+            const sql = await gitText(input.repoPath, input.head, path, input.environment);
             if (sql === null) {
-                if (await gitPathExists(input.repoPath, input.head, path)) {
+                if (await gitPathExists(input.repoPath, input.head, path, input.environment)) {
                     return { entities: null, modulesReferencing: [] };
                 }
                 continue;
@@ -723,7 +723,7 @@ export async function detectSchemaImpact(input) {
         const readHeadFile = (path) => {
             let pending = fileCache.get(path);
             if (!pending) {
-                pending = headFile(input.repoPath, input.head, path)
+                pending = headFile(input.repoPath, input.head, path, input.environment)
                     .then((text) => text === null ? null : referenceFacts(path, text));
                 fileCache.set(path, pending);
             }

package/dist/service.js

@@ -17,7 +17,9 @@ const EXIT_WINDOW_MS = 15 * 60_000;
 const CRASH_PAUSE_MS = 10 * 60_000;
 const STOP_GRACE_MS = 10_000;
 const BOOT_TIME_TOLERANCE_MS = 2 * 60_000;
-const ALLOWED_ENV = ['CLAUDE_CONFIG_DIR', 'CODEX_HOME', 'HOME', 'USERPROFILE'];
+const ALLOWED_ENV = [
+    'CLAUDE_CONFIG_DIR', 'CODEX_HOME', 'HOME', 'TRUING_PARALLEL_STEPS', 'USERPROFILE',
+];
 const defaultIo = {
     exists: existsSync,
     mkdir: (path) => mkdirSync(path, { recursive: true }),
@@ -697,10 +699,13 @@ export function serviceStatus(paths = servicePaths(), io = defaultIo) {
         pairings: (config?.pairings ?? []).map((pairing) => ({
             url: pairing.url,
             workspaceId: pairing.workspaceId,
-            projects: pairing.connections.map(({ connectionId, repoPath, managed }) => ({
+            projects: pairing.connections.map(({ connectionId, repoPath, managed, label, repository, repositoryStorage }) => ({
                 connectionId,
                 repoPath,
                 ...(managed ? { managed } : {}),
+                ...(label ? { label } : {}),
+                ...(repository ? { repository } : {}),
+                ...(repositoryStorage ? { repositoryStorage } : {}),
             })),
             workspaceTasks: pairing.pollWorkspaceTasks
                 ? { backend: pairing.workspaceBackend ?? 'api-key' }

package/dist/surface-mapper.js

@@ -150,6 +150,33 @@ export async function readReuseChangeSet(sandboxPath, candidateCommit, headCommi
         return null;
     }
 }
+/** Compare two independently acquired snapshots without assuming either shallow repository has the
+ * other's history. Rename/copy detection is deliberately conservative: add+delete declines reuse. */
+export function compareSurfaceSnapshotTrees(base, head) {
+    const paths = [...new Set([...base.entries.keys(), ...head.entries.keys()])]
+        .sort((left, right) => left.localeCompare(right));
+    const changes = [];
+    for (const path of paths) {
+        const before = base.entries.get(path);
+        const after = head.entries.get(path);
+        if (!before)
+            changes.push({ status: 'A', path });
+        else if (!after)
+            changes.push({ status: 'D', path });
+        else if (before.mode !== after.mode || before.type !== after.type)
+            changes.push({ status: 'T', path });
+        else if (before.object !== after.object)
+            changes.push({ status: 'M', path });
+    }
+    return changes;
+}
+export async function readSurfaceSnapshotChangeSet(basePath, baseCommit, headPath, headCommit) {
+    const [base, head] = await Promise.all([
+        enumerateTrackedFiles(basePath, baseCommit),
+        enumerateTrackedFiles(headPath, headCommit),
+    ]);
+    return compareSurfaceSnapshotTrees(base, head);
+}
 function isRecord(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
@@ -323,22 +350,37 @@ export async function runSurfaceMapping(input) {
         throw new MappingFailure(failure.kind, failure.code, failure.detail);
     }
     try {
-        const tree = await enumerateTrackedFiles(sandbox.path, input.claim.commit);
-        const candidate = input.claim.reuseCandidate;
-        const changeSet = candidate
-            ? await readReuseChangeSet(sandbox.path, candidate.commit, input.claim.commit)
-            : null;
-        const expansionFiles = new Set(candidate?.expansionFiles ?? []);
-        const reuse = candidate && changeSet
-            && changeSet.every((change) => change.status === 'M' && expansionFiles.has(change.path))
-            ? { candidate, changeSet }
-            : undefined;
-        return await mapSurfaceSnapshot({ ...input, sandboxPath: sandbox.path, tree, ...(reuse ? { reuse } : {}) });
+        return await runSurfaceMappingCheckout({ ...input, checkoutPath: sandbox.path });
     }
     finally {
         await sandbox.cleanup();
     }
 }
+/** Map an already verified, attempt-owned checkout. The caller owns its repository lease. */
+export async function runSurfaceMappingCheckout(input) {
+    input.assertLive?.();
+    const tree = await enumerateTrackedFiles(input.checkoutPath, input.claim.commit);
+    input.assertLive?.();
+    const candidate = input.claim.reuseCandidate;
+    const changeSet = candidate
+        ? input.reuseChangeSet === undefined
+            ? await readReuseChangeSet(input.checkoutPath, candidate.commit, input.claim.commit)
+            : input.reuseChangeSet
+        : null;
+    const expansionFiles = new Set(candidate?.expansionFiles ?? []);
+    const reuse = candidate && changeSet
+        && changeSet.every((change) => change.status === 'M' && expansionFiles.has(change.path))
+        ? { candidate, changeSet }
+        : undefined;
+    const manifest = await mapSurfaceSnapshot({
+        ...input,
+        sandboxPath: input.checkoutPath,
+        tree,
+        ...(reuse ? { reuse } : {}),
+    });
+    input.assertLive?.();
+    return manifest;
+}
 export function canonicalManifestJson(manifest) {
     const canonical = (value) => {
         if (Array.isArray(value))

package/dist/text-model.js

@@ -1,3 +1,4 @@
+import { toAnthropicOutputSchema } from './anthropic-output-schema.js';
 const PURPOSE_ERRORS = {
     'verify_module:file_select': {
         refusal: null,
@@ -56,6 +57,52 @@ export class ModelRefusalError extends Error {
         this.category = category;
     }
 }
+/** Safe by construction: provider output and model text are never attached to this error. */
+export class WholeReadTransportError extends Error {
+    code;
+    source;
+    resetAt;
+    retryAfterMs;
+    category;
+    constructor(code, source, resetAt, retryAfterMs, category) {
+        super(code);
+        this.code = code;
+        this.source = source;
+        this.resetAt = resetAt;
+        this.retryAfterMs = retryAfterMs;
+        this.category = category;
+        this.name = 'WholeReadTransportError';
+    }
+}
+function retryAfterMs(error) {
+    if (!error || typeof error !== 'object')
+        return undefined;
+    const headers = error.headers;
+    const raw = headers?.get?.('retry-after');
+    if (!raw)
+        return undefined;
+    const seconds = Number(raw);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return seconds * 1000;
+    const at = Date.parse(raw);
+    return Number.isFinite(at) ? Math.max(0, at - Date.now()) : undefined;
+}
+function safeAnthropicFailure(error) {
+    if (error instanceof DOMException && error.name === 'AbortError') {
+        return new WholeReadTransportError('cancelled', 'anthropic_api');
+    }
+    const candidate = error;
+    const status = typeof candidate?.status === 'number' ? candidate.status : 0;
+    const type = typeof candidate?.error?.type === 'string' ? candidate.error.type : '';
+    const message = typeof candidate?.message === 'string' ? candidate.message : '';
+    if (status === 429 || type === 'rate_limit_error') {
+        return new WholeReadTransportError('provider_rate_limit', 'anthropic_api', undefined, retryAfterMs(error));
+    }
+    if (status === 402 || /billing|credit balance|payment required/i.test(`${type} ${message}`)) {
+        return new WholeReadTransportError('billing_exhausted', 'anthropic_api');
+    }
+    return new WholeReadTransportError('capability_failure', 'anthropic_api');
+}
 /** The reply text once a refusal is ruled out. A mid-output fallback continues the declined
  * model's partial text in a later block, so every text block is joined; null when there is none. */
 export function replyText(message, refusal) {
@@ -96,26 +143,62 @@ export function anthropicTextModel(client) {
         const content = request.purpose.endsWith(':file_select') && blocks.length === 1 && blocks[0].type === 'text'
             ? blocks[0].text
             : blocks;
-        const stream = streamWithFallback(client, {
+        const thinking = { type: request.thinking ?? 'adaptive' };
+        const params = {
             model: request.model,
             max_tokens: request.maxTokens,
-            thinking: { type: 'adaptive' },
+            thinking,
             output_config: request.schema
-                ? { effort: request.effort, format: { type: 'json_schema', schema: request.schema } }
+                ? { effort: request.effort, format: { type: 'json_schema',
+                        schema: toAnthropicOutputSchema(request.schema) } }
                 : { effort: request.effort },
             system: request.system,
             messages: [{ role: 'user', content }],
-        });
-        const message = await stream.finalMessage();
+        };
+        let message;
+        try {
+            const stream = request.wholeRead
+                ? client.beta.messages.stream({ ...params, betas: [FALLBACK_BETA], fallbacks: DEFAULT_FALLBACKS }, {
+                    signal: request.wholeRead.signal,
+                })
+                : streamWithFallback(client, params);
+            message = await stream.finalMessage();
+        }
+        catch (error) {
+            if (request.wholeRead)
+                throw safeAnthropicFailure(error);
+            throw error;
+        }
         const errors = PURPOSE_ERRORS[request.purpose] ?? {
             refusal: `The model declined the ${request.purpose} call.`,
             empty: `The ${request.purpose} call returned no text.`,
         };
         // A purpose with no refusal wording of its own still fails as a refusal, under its empty-reply
         // wording — never by reading whatever partial text the declined attempt left behind.
-        const text = replyText(message, errors.refusal ?? errors.empty);
-        if (!text)
+        let text;
+        try {
+            text = replyText(message, errors.refusal ?? errors.empty);
+        }
+        catch (error) {
+            if (request.wholeRead && error instanceof ModelRefusalError) {
+                throw new WholeReadTransportError('model_declined', 'anthropic_api', undefined, undefined, error.category);
+            }
+            throw error;
+        }
+        if (!text) {
+            if (request.wholeRead)
+                throw new WholeReadTransportError('capability_failure', 'anthropic_api');
             throw new Error(errors.empty);
-        return { text, usage: usageRecord(message.usage) };
+        }
+        const usage = usageRecord(message.usage);
+        return {
+            text,
+            usage,
+            ...(request.wholeRead ? { metadata: {
+                    finishReason: message.stop_reason,
+                    model: typeof message.model === 'string' ? message.model : null,
+                    usageAvailable: usage !== null,
+                } } : {}),
+        };
     };
 }

package/dist/whole-read/archive.js

@@ -0,0 +1,196 @@
+import { createRequire } from 'node:module';
+import { Readable, Transform } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { createGunzip } from 'node:zlib';
+const require = createRequire(import.meta.url);
+const tar = require('tar-stream');
+const DEFAULT_LIMITS = {
+    maxCompressedBytes: 64 * 1024 * 1024,
+    maxUncompressedBytes: 256 * 1024 * 1024,
+    maxMemberBytes: 64 * 1024 * 1024,
+    maxMembers: 100_000,
+};
+/** Safe parser error: archive paths and contents are deliberately excluded. */
+export class ArchiveInspectionError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'ArchiveInspectionError';
+    }
+}
+function fail(code) {
+    throw new ArchiveInspectionError(code);
+}
+function resolvedLimits(input) {
+    const limits = { ...DEFAULT_LIMITS };
+    for (const key of Object.keys(DEFAULT_LIMITS)) {
+        const value = input.limits?.[key];
+        if (value === undefined)
+            continue;
+        if (!Number.isSafeInteger(value) || value <= 0 || value > DEFAULT_LIMITS[key]) {
+            return fail('archive_invalid');
+        }
+        limits[key] = value;
+    }
+    return limits;
+}
+function byteCounter(limit, signal) {
+    let total = 0;
+    return new Transform({
+        transform(chunk, _encoding, callback) {
+            if (signal?.aborted) {
+                callback(new ArchiveInspectionError('cancelled'));
+                return;
+            }
+            total += chunk.byteLength;
+            callback(total > limit ? new ArchiveInspectionError('resource_limit') : null, chunk);
+        },
+    });
+}
+function safeParts(name) {
+    if (name.length === 0 || name.startsWith('/') || name.includes('\\') || name.includes('\0')) {
+        return null;
+    }
+    const trimmed = name.endsWith('/') ? name.slice(0, -1) : name;
+    if (trimmed.length === 0)
+        return null;
+    const parts = trimmed.split('/');
+    return parts.every((part) => part.length > 0 && part !== '.' && part !== '..') ? parts : null;
+}
+function conflicts(path, kind, seen) {
+    if (seen.has(path))
+        return true;
+    let slash = path.indexOf('/');
+    while (slash >= 0) {
+        if (seen.get(path.slice(0, slash)) === 'file')
+            return true;
+        slash = path.indexOf('/', slash + 1);
+    }
+    if (kind === 'file') {
+        for (const existing of seen.keys()) {
+            if (existing.startsWith(`${path}/`))
+                return true;
+        }
+    }
+    return false;
+}
+async function parseArchive(input) {
+    if (input.signal?.aborted)
+        return fail('cancelled');
+    const limits = resolvedLimits(input);
+    const source = Readable.from(input.compressed);
+    const extractor = tar.extract();
+    const members = [];
+    const seen = new Map();
+    let prefix = null;
+    let rootSeen = false;
+    let memberCount = 0;
+    const abort = () => {
+        source.destroy(new ArchiveInspectionError('cancelled'));
+    };
+    input.signal?.addEventListener('abort', abort, { once: true });
+    extractor.on('entry', (header, stream, next) => {
+        memberCount += 1;
+        const parts = typeof header.name === 'string' ? safeParts(header.name) : null;
+        if (memberCount > limits.maxMembers || parts === null) {
+            stream.resume();
+            next(new ArchiveInspectionError(memberCount > limits.maxMembers ? 'resource_limit' : 'archive_invalid'));
+            return;
+        }
+        if (prefix === null)
+            prefix = parts[0];
+        if (parts[0] !== prefix) {
+            stream.resume();
+            next(new ArchiveInspectionError('archive_invalid'));
+            return;
+        }
+        const type = header.type ?? 'file';
+        if (type !== 'file' && type !== 'directory') {
+            stream.resume();
+            next(new ArchiveInspectionError('archive_invalid'));
+            return;
+        }
+        if (type !== 'directory' && header.name.endsWith('/')) {
+            stream.resume();
+            next(new ArchiveInspectionError('archive_invalid'));
+            return;
+        }
+        if (parts.length === 1) {
+            if (type !== 'directory' || rootSeen || header.size !== 0) {
+                stream.resume();
+                next(new ArchiveInspectionError('archive_invalid'));
+                return;
+            }
+            rootSeen = true;
+            stream.once('end', next);
+            stream.resume();
+            return;
+        }
+        const path = parts.slice(1).join('/');
+        if (conflicts(path, type, seen)) {
+            stream.resume();
+            next(new ArchiveInspectionError('archive_invalid'));
+            return;
+        }
+        seen.set(path, type);
+        if (type === 'directory') {
+            if (header.size !== 0) {
+                stream.resume();
+                next(new ArchiveInspectionError('archive_invalid'));
+                return;
+            }
+            stream.once('end', next);
+            stream.resume();
+            return;
+        }
+        if (!Number.isSafeInteger(header.size) || Number(header.size) < 0
+            || Number(header.size) > limits.maxMemberBytes) {
+            stream.resume();
+            next(new ArchiveInspectionError(Number(header.size) > limits.maxMemberBytes
+                ? 'resource_limit'
+                : 'archive_invalid'));
+            return;
+        }
+        const chunks = [];
+        let size = 0;
+        let tooLarge = false;
+        stream.on('data', (chunk) => {
+            size += chunk.byteLength;
+            if (size <= limits.maxMemberBytes)
+                chunks.push(Buffer.from(chunk));
+            else
+                tooLarge = true;
+        });
+        stream.once('end', () => {
+            if (tooLarge) {
+                next(new ArchiveInspectionError('resource_limit'));
+                return;
+            }
+            if (size !== header.size) {
+                next(new ArchiveInspectionError('archive_invalid'));
+                return;
+            }
+            members.push({ path, size, bytes: Buffer.concat(chunks, size) });
+            next();
+        });
+    });
+    try {
+        await pipeline(source, byteCounter(limits.maxCompressedBytes, input.signal), createGunzip(), byteCounter(limits.maxUncompressedBytes, input.signal), extractor);
+    }
+    catch (error) {
+        if (error instanceof ArchiveInspectionError)
+            throw error;
+        return fail(input.signal?.aborted ? 'cancelled' : 'archive_invalid');
+    }
+    finally {
+        input.signal?.removeEventListener('abort', abort);
+    }
+    return members;
+}
+/** Inspect a GitHub-style gzip tarball without materialising paths on disk. */
+export async function* inspectArchive(input) {
+    const members = await parseArchive(input);
+    for (const member of members)
+        yield member;
+}