codehere 1.0.1 → 1.0.2

package/dist/application/use-cases/write-pass.js

@@ -1,277 +0,0 @@
-/**
- * Write-Pass (W-PASS) primitive · v0.9 S6 · the WRITE counterpart to S1's
- * context-source READ primitive.
- *
- * Demo v12 lines 2030-2050. Every time an agent wants to make a stateful
- * call to a third-party tool (Linear status update, GitHub PR comment,
- * Notion page edit, etc.) it emits a `WritePassIntent`. Codehere mediates:
- *
- *   1. Intent       · agent → codehere · {target, method, payload, reason}
- *   2. Approval     · user → codehere · approve / edit / cancel
- *   3. Mediated send · codehere → third-party · captures response
- *   4. Audit        · chained entry for each step
- *
- * Why this primitive exists: AI 2027 forecasts agentic AI doing autonomous
- * multi-tool writes by mid-2027. Without W-PASS we either (a) hand the
- * agent raw API keys + tokens — every write is invisible to the human,
- * audit-impossible — or (b) ban writes entirely and lose half the value.
- * W-PASS is the middle path: writes happen, but every payload is human-
- * mediated and chain-recorded.
- *
- * This file is PURE LOGIC · no fs, no fetch. CLI + HTTP + UI wrap it.
- */
-import { randomUUID, createHash } from 'crypto';
-/** Errors raised by W-PASS primitive functions. */
-export class WritePassError extends Error {
-    code;
-    constructor(code, message) {
-        super(`[w-pass] ${code}: ${message}`);
-        this.code = code;
-    }
-}
-/* ──────────────────────────────────────────────────────────────────────── */
-/* Pure helpers                                                              */
-/* ──────────────────────────────────────────────────────────────────────── */
-/** Generate a fresh W-PASS id · stable across the intent → decision → send cycle. */
-export function newPassId() {
-    return randomUUID();
-}
-/** Allowed URL schemes for W-PASS targets · matches context-source's namespace
- *  (we want symmetry: read via context-source, write via write-pass, same identifiers). */
-const ALLOWED_SCHEMES = new Set(['linear', 'github', 'figma', 'drawio', 'notion']);
-/**
- * Validate that an intent is well-formed before showing it to the user.
- * Refuse anything we can't audit (unknown scheme, unsupported method, empty
- * reason, etc.). Throws WritePassError with a precise code.
- */
-export function validateIntent(intent) {
-    if (typeof intent !== 'object' || intent === null) {
-        throw new WritePassError('invalid_intent', 'intent must be an object');
-    }
-    const it = intent;
-    if (typeof it.id !== 'string' || it.id.length === 0) {
-        throw new WritePassError('invalid_intent', 'id required');
-    }
-    if (typeof it.sessionId !== 'string' || it.sessionId.length === 0) {
-        throw new WritePassError('invalid_intent', 'sessionId required');
-    }
-    if (typeof it.target !== 'string' || it.target.length === 0) {
-        throw new WritePassError('invalid_intent', 'target required');
-    }
-    const schemeMatch = it.target.match(/^([a-z][a-z0-9+.-]*):\/\//);
-    if (!schemeMatch) {
-        throw new WritePassError('invalid_intent', `target must be a URL with a scheme · got "${it.target}"`);
-    }
-    if (!ALLOWED_SCHEMES.has(schemeMatch[1])) {
-        throw new WritePassError('unsupported_target', `scheme "${schemeMatch[1]}" not allowed · supported: ${[...ALLOWED_SCHEMES].sort().join(', ')}`);
-    }
-    if (typeof it.method !== 'string') {
-        throw new WritePassError('invalid_intent', 'method required');
-    }
-    const m = it.method.toUpperCase();
-    if (m !== 'POST' && m !== 'PUT' && m !== 'PATCH' && m !== 'DELETE') {
-        throw new WritePassError('unsupported_method', `method "${it.method}" not allowed for W-PASS (use context-source for GET)`);
-    }
-    if (typeof it.reason !== 'string' || it.reason.trim().length === 0) {
-        throw new WritePassError('invalid_intent', 'reason required · must be a non-empty one-line "why"');
-    }
-    if (typeof it.emittedAt !== 'number' || !Number.isFinite(it.emittedAt)) {
-        throw new WritePassError('invalid_intent', 'emittedAt required (epoch ms)');
-    }
-    // payload may be any JSON value · we don't constrain shape here · the user
-    // sees it verbatim and decides.
-    return {
-        id: it.id,
-        sessionId: it.sessionId,
-        target: it.target,
-        method: m,
-        payload: it.payload,
-        reason: it.reason,
-        emittedAt: it.emittedAt,
-        emittedBy: typeof it.emittedBy === 'string' ? it.emittedBy : undefined,
-    };
-}
-/** Validate a decision belongs to its intent and carries the fields required for its kind. */
-export function validateDecision(decision, intent) {
-    if (typeof decision !== 'object' || decision === null) {
-        throw new WritePassError('invalid_decision', 'decision must be an object');
-    }
-    const d = decision;
-    if (d.passId !== intent.id) {
-        throw new WritePassError('invalid_decision', `decision.passId "${d.passId}" doesn't match intent.id "${intent.id}"`);
-    }
-    const kind = d.kind;
-    if (kind !== 'approve' && kind !== 'edit' && kind !== 'cancel') {
-        throw new WritePassError('invalid_decision', `kind must be approve | edit | cancel · got "${d.kind}"`);
-    }
-    if (kind === 'edit' && d.editedPayload === undefined) {
-        throw new WritePassError('invalid_decision', 'edit requires editedPayload');
-    }
-    if (typeof d.decidedAt !== 'number' || !Number.isFinite(d.decidedAt)) {
-        throw new WritePassError('invalid_decision', 'decidedAt required (epoch ms)');
-    }
-    return {
-        passId: intent.id,
-        kind,
-        editedPayload: kind === 'edit' ? d.editedPayload : undefined,
-        note: typeof d.note === 'string' ? d.note : undefined,
-        decidedAt: d.decidedAt,
-    };
-}
-/**
- * Apply a decision to an intent and produce the next status.
- * Pure · no I/O. The caller (daemon route) does the network call and produces
- * a `WritePassResponse` which then transitions 'approved'/'edited' → 'sent'.
- */
-export function applyDecision(intent, decision) {
-    if (decision.kind === 'cancel') {
-        return { kind: 'cancelled', intent, decision };
-    }
-    if (decision.kind === 'edit') {
-        return { kind: 'edited', intent, decision, effectivePayload: decision.editedPayload };
-    }
-    return { kind: 'approved', intent, decision };
-}
-/**
- * After codehere does the mediated send, record the response and transition
- * to 'sent' (2xx/3xx) or 'failed' (everything else).
- */
-export function applyResponse(status, response) {
-    const effectivePayload = status.kind === 'edited' ? status.effectivePayload : status.intent.payload;
-    const ok = response.status >= 200 && response.status < 400;
-    return ok
-        ? { kind: 'sent', intent: status.intent, decision: status.decision, effectivePayload, response }
-        : { kind: 'failed', intent: status.intent, decision: status.decision, effectivePayload, response };
-}
-/* ──────────────────────────────────────────────────────────────────────── */
-/* Audit-line shaping                                                        */
-/* ──────────────────────────────────────────────────────────────────────── */
-/**
- * Deterministic JSON for hashing into the audit chain. Same canonical-form
- * rules as thread-export's canonicalize · keys sorted, undefined dropped,
- * non-finite numbers refused. We want two machines that re-serialize the
- * same intent to compute the same hash.
- */
-export function canonicalizeForAudit(value) {
-    if (value === null)
-        return 'null';
-    if (typeof value === 'number') {
-        if (!Number.isFinite(value))
-            throw new Error(`cannot canonicalize non-finite number: ${value}`);
-        return JSON.stringify(value);
-    }
-    if (typeof value === 'string' || typeof value === 'boolean')
-        return JSON.stringify(value);
-    if (Array.isArray(value)) {
-        return '[' + value.map(canonicalizeForAudit).join(',') + ']';
-    }
-    if (typeof value === 'object') {
-        const obj = value;
-        const keys = Object.keys(obj).sort();
-        const parts = keys
-            .filter((k) => obj[k] !== undefined)
-            .map((k) => JSON.stringify(k) + ':' + canonicalizeForAudit(obj[k]));
-        return '{' + parts.join(',') + '}';
-    }
-    if (value === undefined)
-        return 'null';
-    throw new Error(`cannot canonicalize type: ${typeof value}`);
-}
-/** SHA-256 hash of canonicalize(value) · 16-char hex prefix for inline display. */
-export function shortContentHash(value) {
-    return createHash('sha256').update(canonicalizeForAudit(value)).digest('hex').slice(0, 16);
-}
-/** Render a status transition as an audit-chain entry. Caller appends it. */
-export function statusToAuditLine(s) {
-    const sessionId = s.intent.sessionId;
-    const timestamp = new Date('response' in s ? s.response.receivedAt : 'decision' in s ? s.decision.decidedAt : s.intent.emittedAt).toISOString();
-    const baseSummary = {
-        passId: s.intent.id,
-        target: s.intent.target,
-        method: s.intent.method,
-        reason: s.intent.reason,
-        payloadHash: shortContentHash(s.intent.payload),
-    };
-    switch (s.kind) {
-        case 'pending':
-            return {
-                toolName: 'WritePass.intent',
-                toolInput: canonicalizeForAudit(baseSummary),
-                riskScore: 0,
-                blocked: false,
-                findings: 0,
-                criticalFindings: 0,
-                sessionId,
-                timestamp,
-            };
-        case 'approved':
-            return {
-                toolName: 'WritePass.approved',
-                toolInput: canonicalizeForAudit({ ...baseSummary, note: s.decision.note }),
-                riskScore: 0,
-                blocked: false,
-                findings: 0,
-                criticalFindings: 0,
-                sessionId,
-                timestamp,
-            };
-        case 'edited':
-            return {
-                toolName: 'WritePass.edited',
-                toolInput: canonicalizeForAudit({
-                    ...baseSummary,
-                    editedPayloadHash: shortContentHash(s.effectivePayload),
-                    note: s.decision.note,
-                }),
-                riskScore: 0,
-                blocked: false,
-                findings: 0,
-                criticalFindings: 0,
-                sessionId,
-                timestamp,
-            };
-        case 'cancelled':
-            return {
-                toolName: 'WritePass.cancelled',
-                toolInput: canonicalizeForAudit({ ...baseSummary, note: s.decision.note }),
-                riskScore: 0,
-                blocked: true,
-                findings: 0,
-                criticalFindings: 0,
-                sessionId,
-                timestamp,
-            };
-        case 'sent':
-            return {
-                toolName: 'WritePass.sent',
-                toolInput: canonicalizeForAudit({
-                    ...baseSummary,
-                    effectivePayloadHash: shortContentHash(s.effectivePayload),
-                    responseStatus: s.response.status,
-                }),
-                riskScore: 0,
-                blocked: false,
-                findings: 0,
-                criticalFindings: 0,
-                sessionId,
-                timestamp,
-            };
-        case 'failed':
-            return {
-                toolName: 'WritePass.failed',
-                toolInput: canonicalizeForAudit({
-                    ...baseSummary,
-                    effectivePayloadHash: shortContentHash(s.effectivePayload),
-                    responseStatus: s.response.status,
-                    error: s.response.error,
-                }),
-                riskScore: 0,
-                blocked: false,
-                findings: 1,
-                criticalFindings: 0,
-                sessionId,
-                timestamp,
-            };
-    }
-}
-//# sourceMappingURL=write-pass.js.map

package/dist/domain/audit.js

@@ -1,11 +0,0 @@
-/**
- * Domain types for the tamper-evident-aspiring audit chain.
- *
- * These are pure data shapes — no I/O, no clock, no dependencies. They live in
- * `domain/` (not `infrastructure/hooks/`) so the dependency rule points inward:
- * the hook, the daemon, and the use-cases all import these DOWN from domain,
- * rather than reaching up into a hook file for the core vocabulary.
- * Moved here 2026-06-09 (spec R14 / ARCHITECTURE.md M1).
- */
-export {};
-//# sourceMappingURL=audit.js.map

package/dist/domain/services/codebase-detector.js

@@ -1,85 +0,0 @@
-/**
- * Domain Service: CodebaseDetector
- * Detects and identifies codebase root directory
- */
-import { existsSync } from 'fs';
-import { join, dirname, resolve } from 'path';
-/**
- * Find codebase root (git root, package.json parent, or current directory)
- */
-export function findCodebaseRoot(startPath = process.cwd()) {
-    const resolvedStart = resolve(startPath);
-    const currentDir = resolvedStart;
-    // Try to find git root first
-    const gitRoot = findGitRoot(currentDir);
-    if (gitRoot) {
-        return {
-            rootPath: gitRoot,
-            codebaseId: generateCodebaseId(gitRoot),
-            type: 'git',
-        };
-    }
-    // Try to find package.json
-    const packageRoot = findPackageRoot(currentDir);
-    if (packageRoot) {
-        return {
-            rootPath: packageRoot,
-            codebaseId: generateCodebaseId(packageRoot),
-            type: 'package',
-        };
-    }
-    // Fallback to current directory
-    return {
-        rootPath: currentDir,
-        codebaseId: generateCodebaseId(currentDir),
-        type: 'directory',
-    };
-}
-/**
- * Generate stable codebase ID from path
- * Uses absolute path normalized for cross-platform compatibility
- */
-function generateCodebaseId(path) {
-    // Normalize path (handle Windows/Unix differences)
-    const normalized = resolve(path).replace(/\\/g, '/');
-    // Use path as ID (stable identifier)
-    // For production, could hash this for shorter IDs
-    return normalized;
-}
-/**
- * Find git root directory
- */
-function findGitRoot(startPath) {
-    let currentDir = startPath;
-    const root = currentDir.split(/[/\\]/)[0];
-    while (currentDir !== root) {
-        if (existsSync(join(currentDir, '.git'))) {
-            return currentDir;
-        }
-        const parentDir = dirname(currentDir);
-        if (parentDir === currentDir) {
-            break;
-        }
-        currentDir = parentDir;
-    }
-    return null;
-}
-/**
- * Find package.json root directory
- */
-function findPackageRoot(startPath) {
-    let currentDir = startPath;
-    const root = currentDir.split(/[/\\]/)[0];
-    while (currentDir !== root) {
-        if (existsSync(join(currentDir, 'package.json'))) {
-            return currentDir;
-        }
-        const parentDir = dirname(currentDir);
-        if (parentDir === currentDir) {
-            break;
-        }
-        currentDir = parentDir;
-    }
-    return null;
-}
-//# sourceMappingURL=codebase-detector.js.map

package/dist/domain/task.js

@@ -1,91 +0,0 @@
-/**
- * Domain types for a task's observable shape — status, progress steps, and the
- * end-of-task artifacts. Pure data: no I/O, no behavior, no dependencies. These
- * live in `domain/` so application + infrastructure import them DOWN, rather than
- * reaching up into an adapter file for the core vocabulary.
- * Moved here 2026-06-09 (spec R14 / ARCHITECTURE.md M1) from
- * infrastructure/orchestration/agent-adapter.ts. The `TaskSession` runtime handle
- * (which has behavior: subscribe/kill/appendMessage) and the `AgentAdapter` port
- * stay with the adapters; only the pure data shapes move here.
- */
-/**
- * R13/M3 — THE one owned transition for `artifacts.tests`. Before this, the
- * exit-path re-run mutated the artifact inline in the session manager: the
- * exit-code-authoritative merge, the claim-preservation rule, and the
- * silent-blank-when-unobservable gap all lived in untyped infra code. This is
- * now the only writer of the post-exit tests artifact.
- *
- * Mutates `artifacts` IN PLACE by design: the live TaskSession exposes
- * `artifacts` as a readonly getter over one shared object that the API layer
- * re-reads each poll — replacing the reference would detach the live verdict.
- *
- * Rules (verbatim from the prior inline code, now pinned by unit tests):
- *  - exit code is authoritative: a non-zero exit with no parseable count still
- *    forces failed >= 1, so a "tests pass" claim that didn't pass gets caught;
- *  - the agent's ORIGINAL scrape is preserved as `claimed` so the verifier can
- *    still catch a prose-vs-own-stdout self-contradiction;
- *  - couldn't run → the explicit reason lands in `testsUnobserved` instead of
- *    leaving the artifact silently blank (the R5 leftover).
- */
-export function applyTestObservation(artifacts, observation) {
-    if (!observation.ran) {
-        artifacts.testsUnobserved = observation.skippedReason ?? 'could not re-run the tests';
-        return 'unobserved';
-    }
-    const claimed = artifacts.tests;
-    let failed = observation.failed ?? 0;
-    if (observation.exitCode !== 0 && failed === 0)
-        failed = 1;
-    // LOW #28 (atomic audit) · exit 0 with no parseable count reuses the
-    // AGENT'S claimed number. The exit code is ground truth (the suite ran and
-    // passed) but the COUNT is not — say which is which (countSource) so the
-    // surface can label "re-run ✓ · count as reported" instead of implying the
-    // number itself was observed.
-    const countParsed = observation.passed !== undefined;
-    const passed = observation.passed ?? (observation.exitCode === 0 ? (claimed?.passed ?? 0) : 0);
-    artifacts.tests = {
-        passed,
-        failed,
-        observed: true,
-        ...(countParsed ? {} : { countSource: 'claimed' }),
-        ...(claimed ? { claimed: { passed: claimed.passed, failed: claimed.failed } } : {}),
-        ...(observation.command ? { command: observation.command } : {}),
-        ...(observation.exitCode !== undefined ? { exitCode: observation.exitCode } : {}),
-        ...(observation.durationMs !== undefined ? { durationMs: observation.durationMs } : {}),
-    };
-    delete artifacts.testsUnobserved; // an observed result supersedes any earlier couldn't-observe
-    return 'observed';
-}
-/** Derive the typed completeness view from a session's recorded parts. */
-export function describeCompleted(input) {
-    const a = input.artifacts;
-    return {
-        sessionId: input.sessionId,
-        agent: input.agent,
-        status: input.status,
-        completedAt: input.completedAt,
-        durationMs: input.durationMs,
-        steps: input.steps ?? [],
-        files: a?.files
-            ? { present: a.files }
-            : {
-                absent: a?.noGitTracking
-                    ? "ran in a non-git folder — codehere can't see what changed"
-                    : 'no file changes recorded',
-            },
-        tests: a?.tests
-            ? { present: a.tests }
-            : { absent: a?.testsUnobserved ?? 'not test-relevant — no claim made, no test files touched' },
-        report: input.finalReport?.summary
-            ? { present: { summary: input.finalReport.summary } }
-            : { absent: input.failedReport ? 'report generation failed' : 'no written report' },
-        audit: input.auditRecon
-            ? { present: input.auditRecon }
-            : {
-                // Precise: reconciliation RUNS in the daemon at completion but is
-                // held in memory, not persisted — so a later reader can't see it.
-                absent: 'reconciliation not visible here — it runs in the daemon that observed the exit and is not persisted',
-            },
-    };
-}
-//# sourceMappingURL=task.js.map

package/dist/error-handler.js

@@ -1,139 +0,0 @@
-/**
- * Error classification + circuit breaker for API calls.
- */
-export var ErrorType;
-(function (ErrorType) {
-    ErrorType["RETRYABLE"] = "RETRYABLE";
-    ErrorType["FATAL"] = "FATAL";
-    ErrorType["RATE_LIMIT"] = "RATE_LIMIT";
-    ErrorType["NETWORK"] = "NETWORK";
-    ErrorType["API_ERROR"] = "API_ERROR";
-    ErrorType["VALIDATION"] = "VALIDATION";
-    ErrorType["POLICY"] = "POLICY";
-})(ErrorType || (ErrorType = {}));
-export class EnterpriseError extends Error {
-    errorType;
-    context;
-    retryable;
-    constructor(message, errorType, context, retryable = false) {
-        super(message);
-        this.errorType = errorType;
-        this.context = context;
-        this.retryable = retryable;
-        this.name = 'EnterpriseError';
-    }
-}
-/**
- * Classify error type for appropriate handling
- */
-export function classifyError(error) {
-    if (error instanceof EnterpriseError) {
-        return error.errorType;
-    }
-    // Check for 429 status code directly (Cohere SDK errors)
-    if (error && typeof error === 'object') {
-        const err = error;
-        if (err.statusCode === 429 || err.status === 429) {
-            return ErrorType.RATE_LIMIT;
-        }
-        // Check error name/class
-        const errorName = err.constructor?.name || err.name || '';
-        if (errorName.includes('TooManyRequests') || errorName === 'TooManyRequestsError') {
-            return ErrorType.RATE_LIMIT;
-        }
-        // Check body/message for trial key quota messages
-        const body = err.body || err.message || '';
-        if (typeof body === 'string' && body.includes('Trial key') && body.includes('1000 API calls')) {
-            return ErrorType.RATE_LIMIT;
-        }
-    }
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    const lowerMessage = errorMessage.toLowerCase();
-    // Rate limiting - check message content
-    if (lowerMessage.includes('rate limit') ||
-        lowerMessage.includes('429') ||
-        lowerMessage.includes('too many requests') ||
-        lowerMessage.includes('toomanyrequests') ||
-        (lowerMessage.includes('trial key') && lowerMessage.includes('1000'))) {
-        return ErrorType.RATE_LIMIT;
-    }
-    // Network errors
-    if (lowerMessage.includes('network') || lowerMessage.includes('timeout') || lowerMessage.includes('econnrefused')) {
-        return ErrorType.NETWORK;
-    }
-    // API errors
-    if (lowerMessage.includes('api') || lowerMessage.includes('cohere')) {
-        return ErrorType.API_ERROR;
-    }
-    // Validation errors
-    if (lowerMessage.includes('validation') || lowerMessage.includes('invalid')) {
-        return ErrorType.VALIDATION;
-    }
-    // Default to retryable
-    return ErrorType.RETRYABLE;
-}
-/**
- * Circuit breaker pattern for API calls
- */
-export class CircuitBreaker {
-    threshold;
-    resetTimeout;
-    failures = 0;
-    lastFailureTime = 0;
-    state = 'CLOSED';
-    constructor(threshold = 5, resetTimeout = 30000) {
-        this.threshold = threshold;
-        this.resetTimeout = resetTimeout;
-    }
-    async execute(operation) {
-        // Check if circuit should be reset
-        if (this.state === 'OPEN') {
-            const timeSinceLastFailure = Date.now() - this.lastFailureTime;
-            if (timeSinceLastFailure > this.resetTimeout) {
-                this.state = 'HALF_OPEN';
-            }
-            else {
-                throw new EnterpriseError('Circuit breaker is OPEN. Service unavailable.', ErrorType.API_ERROR, {
-                    operation: 'circuit_breaker',
-                    timestamp: new Date().toISOString(),
-                    errorType: ErrorType.API_ERROR,
-                    originalError: new Error('Circuit breaker open'),
-                }, false);
-            }
-        }
-        try {
-            const result = await operation();
-            // Success - reset failures if in HALF_OPEN
-            if (this.state === 'HALF_OPEN') {
-                this.state = 'CLOSED';
-                this.failures = 0;
-            }
-            else if (this.failures > 0) {
-                this.failures = 0;
-            }
-            return result;
-        }
-        catch (error) {
-            this.failures++;
-            this.lastFailureTime = Date.now();
-            // Open circuit if threshold exceeded
-            if (this.failures >= this.threshold) {
-                this.state = 'OPEN';
-            }
-            throw error;
-        }
-    }
-    getState() {
-        return this.state;
-    }
-    reset() {
-        this.failures = 0;
-        this.state = 'CLOSED';
-        this.lastFailureTime = 0;
-    }
-}
-/**
- * Global circuit breaker for Cohere API
- */
-export const cohereCircuitBreaker = new CircuitBreaker(5, 30000);
-//# sourceMappingURL=error-handler.js.map

package/dist/infrastructure/completion/bash-completion.js

@@ -1,29 +0,0 @@
-/**
- * Bash Completion Script Generator
- *
- * Completions are generated from the REAL registered command list passed by
- * the caller — the alpha-era hardcoded set (`ask plan orchestrate …`) shipped
- * completions for commands that never existed (caught by the 2026-06-07
- * v1-readiness audit, Lane C).
- */
-export function generateBashCompletion(commands) {
-    const opts = commands.map((c) => c.name).join(' ');
-    return `# Codehere bash completion
-_complete_codehere() {
-  local cur prev opts
-  COMPREPLY=()
-  cur="\${COMP_WORDS[COMP_CWORD]}"
-  prev="\${COMP_WORDS[COMP_CWORD-1]}"
-  opts="${opts}"
-
-  if [[ \${cur} == -* ]]; then
-    COMPREPLY=($(compgen -W "--help --version" -- \${cur}))
-  else
-    COMPREPLY=($(compgen -W "\${opts}" -- \${cur}))
-  fi
-}
-
-complete -F _complete_codehere codehere
-`;
-}
-//# sourceMappingURL=bash-completion.js.map

package/dist/infrastructure/completion/fish-completion.js

@@ -1,17 +0,0 @@
-/**
- * Fish Completion Script Generator
- *
- * Completions are generated from the REAL registered command list passed by
- * the caller (see bash-completion.ts header for the audit history).
- */
-export function generateFishCompletion(commands) {
-    const lines = commands
-        .map((c) => `complete -c codehere -n __fish_use_subcommand -a ${c.name} -d "${c.description.replace(/"/g, '')}"`)
-        .join('\n');
-    return `# Codehere fish completion
-complete -c codehere -f
-
-${lines}
-`;
-}
-//# sourceMappingURL=fish-completion.js.map

package/dist/infrastructure/completion/zsh-completion.js

@@ -1,25 +0,0 @@
-/**
- * Zsh Completion Script Generator
- *
- * Completions are generated from the REAL registered command list passed by
- * the caller (see bash-completion.ts header for the audit history).
- */
-export function generateZshCompletion(commands) {
-    // zsh _describe entries are 'name:description' — strip colons/quotes from
-    // descriptions so they can't break the entry syntax.
-    const entries = commands.map((c) => `    '${c.name}:${c.description.replace(/['":]/g, '')}'`).join('\n');
-    return `#compdef codehere
-
-_codehere() {
-  local -a commands
-  commands=(
-${entries}
-  )
-
-  _describe 'codehere' commands
-}
-
-_codehere "$@"
-`;
-}
-//# sourceMappingURL=zsh-completion.js.map