salmon-loop 0.2.3

package/dist/cli/commands/tool-names.js

@@ -0,0 +1,155 @@
+import * as os from 'os';
+import * as path from 'path';
+import { getLogger, registerAllBuiltins, skillToToolSpec, SkillParser, ToolRegistry, } from '../../core/facades/cli-command-tool-names.js';
+import { existsSync, readFileUtf8, readFileUtf8Sync, readdirDirents, readdirDirentsSync, safePathJoin, stat, statSync, } from '../utils/safe-fs.js';
+const VALID_SIDE_EFFECTS = new Set([
+    'none',
+    'fs_read',
+    'fs_write',
+    'process',
+    'network',
+    'git_read',
+    'git_write',
+]);
+const toolNameCache = new Map();
+async function loadSkillsFromPath(root) {
+    if (!existsSync(root))
+        return [];
+    const entries = await readdirDirents(root, root);
+    const skills = [];
+    for (const entry of entries) {
+        const skillFile = entry.isDirectory()
+            ? safePathJoin(root, entry.name, 'SKILL.md')
+            : entry.name.endsWith('.md')
+                ? safePathJoin(root, entry.name)
+                : null;
+        if (!skillFile || !existsSync(skillFile, root))
+            continue;
+        try {
+            const content = await readFileUtf8(skillFile, root);
+            skills.push(SkillParser.parse(content, skillFile));
+        }
+        catch (error) {
+            getLogger().warn(`Failed to load skill at ${skillFile}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return skills;
+}
+function getSkillSearchPaths(repoRoot) {
+    return [
+        path.join(os.homedir(), '.claude/skills'),
+        path.join(repoRoot, '.salmonloop/skills'),
+        path.join(repoRoot, '.claude/skills'),
+    ];
+}
+async function computeSkillSignature(repoRoot) {
+    const parts = [];
+    for (const searchPath of getSkillSearchPaths(repoRoot)) {
+        try {
+            const stats = await stat(searchPath);
+            parts.push(`${searchPath}:${stats.mtimeMs}`);
+        }
+        catch {
+            parts.push(`${searchPath}:missing`);
+        }
+    }
+    return parts.join('|');
+}
+function computeSkillSignatureSync(repoRoot) {
+    const parts = [];
+    for (const searchPath of getSkillSearchPaths(repoRoot)) {
+        try {
+            const stats = statSync(searchPath);
+            parts.push(`${searchPath}:${stats.mtimeMs}`);
+        }
+        catch {
+            parts.push(`${searchPath}:missing`);
+        }
+    }
+    return parts.join('|');
+}
+function loadSkillsFromPathSync(root) {
+    if (!existsSync(root))
+        return [];
+    const entries = readdirDirentsSync(root, root);
+    const skills = [];
+    for (const entry of entries) {
+        const skillFile = entry.isDirectory()
+            ? safePathJoin(root, entry.name, 'SKILL.md')
+            : entry.name.endsWith('.md')
+                ? safePathJoin(root, entry.name)
+                : null;
+        if (!skillFile || !existsSync(skillFile, root))
+            continue;
+        try {
+            const content = readFileUtf8Sync(skillFile, root);
+            skills.push(SkillParser.parse(content, skillFile));
+        }
+        catch (error) {
+            getLogger().warn(`Failed to load skill at ${skillFile}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return skills;
+}
+export async function getKnownToolNames(repoRoot) {
+    const signature = await computeSkillSignature(repoRoot);
+    const cached = toolNameCache.get(repoRoot);
+    if (cached && cached.signature === signature)
+        return cached.names;
+    const registry = new ToolRegistry();
+    registerAllBuiltins(registry);
+    for (const searchPath of getSkillSearchPaths(repoRoot)) {
+        const skills = await loadSkillsFromPath(searchPath);
+        for (const skill of skills) {
+            try {
+                registry.register(skillToToolSpec(skill));
+            }
+            catch (error) {
+                const label = skill.metadata?.name || skill.id;
+                getLogger().warn(`Failed to register skill ${label}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    const names = new Set(registry.listAll().map((spec) => spec.name));
+    toolNameCache.set(repoRoot, { names, signature });
+    return names;
+}
+export function getKnownToolNamesSync(repoRoot) {
+    const signature = computeSkillSignatureSync(repoRoot);
+    const cached = toolNameCache.get(repoRoot);
+    if (cached && cached.signature === signature)
+        return cached.names;
+    const registry = new ToolRegistry();
+    registerAllBuiltins(registry);
+    for (const searchPath of getSkillSearchPaths(repoRoot)) {
+        const skills = loadSkillsFromPathSync(searchPath);
+        for (const skill of skills) {
+            try {
+                registry.register(skillToToolSpec(skill));
+            }
+            catch (error) {
+                const label = skill.metadata?.name || skill.id;
+                getLogger().warn(`Failed to register skill ${label}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    const names = new Set(registry.listAll().map((spec) => spec.name));
+    toolNameCache.set(repoRoot, { names, signature });
+    return names;
+}
+export function clearKnownToolNames(repoRoot) {
+    if (repoRoot) {
+        toolNameCache.delete(repoRoot);
+        return;
+    }
+    toolNameCache.clear();
+}
+export function validateSideEffects(raw) {
+    if (!raw || raw.length === 0)
+        return {};
+    const invalid = raw.filter((effect) => !VALID_SIDE_EFFECTS.has(effect));
+    if (invalid.length > 0)
+        return { invalid };
+    return { valid: raw };
+}
+//# sourceMappingURL=tool-names.js.map

package/dist/cli/commands/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/cli/commands/utils.js

@@ -0,0 +1,42 @@
+import * as crypto from 'crypto';
+/**
+ * Parses input to provide a structured context for suggestions.
+ */
+export function parseSuggestionContext(input) {
+    const trimmed = input.trimStart();
+    const parts = trimmed.split(/\s+/);
+    // argIndex always points to the current argument slot being filled
+    // e.g., "/session " splits to ["/session", ""], argIndex is 1.
+    const argIndex = parts.length - 1;
+    const currentPrefix = parts[argIndex] || '';
+    const isSpaceTrailing = input.endsWith(' ');
+    return { argIndex, currentPrefix, isSpaceTrailing };
+}
+export function parseToken(tokens, key) {
+    const prefix = `${key}=`;
+    const token = tokens.find((t) => t.startsWith(prefix));
+    if (!token)
+        return undefined;
+    return token.slice(prefix.length);
+}
+export function parseTokenList(tokens, key) {
+    const raw = parseToken(tokens, key);
+    if (!raw)
+        return undefined;
+    const values = raw
+        .split(',')
+        .map((v) => v.trim())
+        .filter(Boolean);
+    return values.length > 0 ? values : undefined;
+}
+export function hashArgsInput(raw) {
+    let payload = raw;
+    try {
+        payload = JSON.stringify(JSON.parse(raw));
+    }
+    catch {
+        payload = raw;
+    }
+    return crypto.createHash('sha256').update(payload).digest('hex');
+}
+//# sourceMappingURL=utils.js.map

package/dist/cli/config.js

@@ -0,0 +1,16 @@
+export const CHAT_QUEUE_CONFIG = {
+    MAX_SIZE: 10,
+    OVERFLOW_STRATEGY: 'reject',
+    THINKING_SHOW_DELAY_MS: 50, // Reduced from 120ms for faster response feel
+    THINKING_MIN_VISIBLE_MS: 150, // Reduced from 300ms to minimize perceived lag
+    TASK_TIMEOUT_MS: 10 * 60 * 1000,
+};
+export const TOOL_AUTH_CONFIG = {
+    SESSION_TTL_MS: 30 * 60 * 1000,
+    AUTO_ALLOW_RISK: {
+        low: true,
+        medium: false,
+        high: false,
+    },
+};
+//# sourceMappingURL=config.js.map

package/dist/cli/crash-reporter.js

@@ -0,0 +1,5 @@
+import { getLogger } from '../core/observability/logger.js';
+export function reportCliCrash(err) {
+    getLogger().error('CLI execution crashed', err, true);
+}
+//# sourceMappingURL=crash-reporter.js.map

package/dist/cli/headless/anthropic-stream-normalized-encoder.js

@@ -0,0 +1,164 @@
+import { encodeAnthropicStreamEvent, } from './anthropic-stream-protocol.js';
+export function encodeNormalizedToAnthropicStreamLines(params) {
+    if (params.event.type === 'normalized.message_start') {
+        return [
+            encodeAnthropicStreamEvent({
+                sessionId: params.sessionId,
+                event: {
+                    type: 'message_start',
+                    message: {
+                        id: params.event.messageId,
+                        type: 'message',
+                        role: params.event.role,
+                        content: [],
+                    },
+                },
+            }),
+        ];
+    }
+    if (params.event.type === 'normalized.content_block_start') {
+        if (params.event.blockType === 'text') {
+            return [
+                encodeAnthropicStreamEvent({
+                    sessionId: params.sessionId,
+                    event: {
+                        type: 'content_block_start',
+                        index: params.event.index,
+                        content_block: { type: 'text', text: '' },
+                    },
+                }),
+            ];
+        }
+        return [];
+    }
+    if (params.event.type === 'normalized.content_block_delta') {
+        return [
+            encodeAnthropicStreamEvent({
+                sessionId: params.sessionId,
+                event: {
+                    type: 'content_block_delta',
+                    index: params.event.index,
+                    delta: { type: 'text_delta', text: params.event.text },
+                },
+            }),
+        ];
+    }
+    if (params.event.type === 'normalized.content_block_end') {
+        return [
+            encodeAnthropicStreamEvent({
+                sessionId: params.sessionId,
+                event: { type: 'content_block_stop', index: params.event.index },
+            }),
+        ];
+    }
+    if (params.event.type === 'normalized.message_end') {
+        return [
+            encodeAnthropicStreamEvent({
+                sessionId: params.sessionId,
+                event: {
+                    type: 'message_stop',
+                    stop_reason: params.event.finishReason ?? 'end_turn',
+                },
+            }),
+        ];
+    }
+    if (params.event.type === 'normalized.tool_request_start') {
+        const parentToolUseId = params.event.callId;
+        const input = {};
+        return [
+            encodeAnthropicStreamEvent({
+                sessionId: params.sessionId,
+                parentToolUseId,
+                event: {
+                    type: 'message_start',
+                    message: {
+                        id: `tool_use:${parentToolUseId}`,
+                        type: 'message',
+                        role: 'assistant',
+                        content: [],
+                    },
+                },
+            }),
+            encodeAnthropicStreamEvent({
+                sessionId: params.sessionId,
+                parentToolUseId,
+                event: {
+                    type: 'content_block_start',
+                    index: 0,
+                    content_block: {
+                        type: 'tool_use',
+                        id: parentToolUseId,
+                        name: params.event.toolName,
+                        input,
+                    },
+                },
+            }),
+            encodeAnthropicStreamEvent({
+                sessionId: params.sessionId,
+                parentToolUseId,
+                event: { type: 'content_block_stop', index: 0 },
+            }),
+            encodeAnthropicStreamEvent({
+                sessionId: params.sessionId,
+                parentToolUseId,
+                event: { type: 'message_stop', stop_reason: 'tool_use' },
+            }),
+        ];
+    }
+    if (params.event.type === 'normalized.tool_call_end') {
+        const parentToolUseId = params.event.callId;
+        const isError = params.event.status !== 'ok';
+        const summaryParts = [];
+        summaryParts.push(`tool=${params.event.toolName}`);
+        summaryParts.push(`status=${params.event.status}`);
+        if (typeof params.event.durationMs === 'number') {
+            summaryParts.push(`duration_ms=${params.event.durationMs}`);
+        }
+        if (params.event.errorCode)
+            summaryParts.push(`error_code=${params.event.errorCode}`);
+        let content = summaryParts.join(' ');
+        if (params.event.outputSummary)
+            content += `\noutput_summary=${params.event.outputSummary}`;
+        return [
+            encodeAnthropicStreamEvent({
+                sessionId: params.sessionId,
+                parentToolUseId,
+                event: {
+                    type: 'message_start',
+                    message: {
+                        id: `tool_result:${parentToolUseId}`,
+                        type: 'message',
+                        role: 'user',
+                        content: [],
+                    },
+                },
+            }),
+            encodeAnthropicStreamEvent({
+                sessionId: params.sessionId,
+                parentToolUseId,
+                event: {
+                    type: 'content_block_start',
+                    index: 0,
+                    content_block: {
+                        type: 'tool_result',
+                        tool_use_id: parentToolUseId,
+                        is_error: isError,
+                        content,
+                    },
+                },
+            }),
+            encodeAnthropicStreamEvent({
+                sessionId: params.sessionId,
+                parentToolUseId,
+                event: { type: 'content_block_stop', index: 0 },
+            }),
+            encodeAnthropicStreamEvent({
+                sessionId: params.sessionId,
+                parentToolUseId,
+                event: { type: 'message_stop', stop_reason: 'end_turn' },
+            }),
+        ];
+    }
+    return [];
+}
+//# sourceMappingURL=anthropic-stream-normalized-encoder.js.map

package/dist/cli/headless/anthropic-stream-protocol.js

@@ -0,0 +1,62 @@
+import { getExitCode } from '../../core/facades/cli-headless.js';
+function dropUndefined(obj) {
+    const out = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (value === undefined)
+            continue;
+        out[key] = value;
+    }
+    return out;
+}
+export function getAnthropicExitCode(result) {
+    return getExitCode(result);
+}
+export function encodeAnthropicStart(params) {
+    return dropUndefined({
+        type: 'start',
+        session_id: params.sessionId,
+        command: params.mode,
+        repo_path: params.repoPath,
+        instruction: params.instruction,
+    });
+}
+export function encodeAnthropicStreamEvent(params) {
+    return dropUndefined({
+        type: 'stream_event',
+        session_id: params.sessionId,
+        event: params.event,
+        parent_tool_use_id: params.parentToolUseId,
+    });
+}
+export function encodeAnthropicResult(params) {
+    const exitCode = getAnthropicExitCode(params.loopResult);
+    return dropUndefined({
+        type: 'result',
+        session_id: params.sessionId,
+        success: Boolean(params.loopResult.success),
+        exit_code: exitCode,
+        reason: params.loopResult.reason,
+        result: params.resultText,
+    });
+}
+export function encodeAnthropicError(params) {
+    return {
+        type: 'error',
+        session_id: params.sessionId,
+        error: dropUndefined({
+            message: params.message,
+            name: params.name,
+            stack: params.stack,
+        }),
+    };
+}
+export function encodeAnthropicEnd(params) {
+    const exitCode = getAnthropicExitCode(params.loopResult);
+    return {
+        type: 'end',
+        session_id: params.sessionId,
+        success: Boolean(params.loopResult.success),
+        exit_code: exitCode,
+    };
+}
+//# sourceMappingURL=anthropic-stream-protocol.js.map

package/dist/cli/headless/json-protocol.js

@@ -0,0 +1,124 @@
+function toExitCode(result) {
+    if (result.reason === 'Operation cancelled by user')
+        return 130;
+    return result.success ? 0 : 1;
+}
+function toUsage(result) {
+    const usage = result.usage;
+    if (!usage)
+        return undefined;
+    return {
+        input_tokens: usage.inputTokens,
+        output_tokens: usage.outputTokens,
+        total_tokens: usage.totalTokens,
+    };
+}
+function toAuthorizationDecisions(result) {
+    const decisions = result.authorizationDecisions;
+    if (!Array.isArray(decisions) || decisions.length === 0)
+        return undefined;
+    return decisions.map((d) => ({
+        call_id: d.callId,
+        tool_name: d.toolName,
+        phase: d.phase,
+        outcome: d.outcome,
+        source: d.source,
+        reason: d.reason,
+        ttl_ms: d.ttlMs,
+        persist: d.persist,
+        risk_level: d.riskLevel,
+        side_effects: d.sideEffects,
+        timestamp: d.timestamp,
+    }));
+}
+export function encodeJsonResult(params) {
+    const overrides = params.overrides;
+    const exitCode = overrides?.exitCode ?? toExitCode(params.loopResult);
+    const success = overrides?.success ?? Boolean(params.loopResult.success);
+    const safeHint = overrides?.safeHint ?? params.loopResult.safeHint ?? params.loopResult.reason;
+    const remediationSteps = overrides?.remediationSteps ?? params.loopResult.remediationSteps ?? [];
+    const diagnosticCode = overrides?.diagnosticCode ?? params.loopResult.diagnosticCode ?? params.loopResult.reasonCode;
+    const reason = overrides?.reason ?? safeHint;
+    const reasonCode = overrides?.reasonCode ?? params.loopResult.reasonCode;
+    const errorCode = overrides?.errorCode ?? params.loopResult.errorCode;
+    return {
+        result: params.resultText,
+        structured_output: params.structuredOutput,
+        session_id: params.sessionId,
+        metadata: {
+            command: params.mode,
+            repo_path: params.repoPath,
+            instruction: params.instruction,
+            success,
+            exit_code: exitCode,
+            reason,
+            reason_code: reasonCode,
+            diagnostic_code: diagnosticCode,
+            safe_hint: safeHint,
+            remediation_steps: remediationSteps,
+            attempts: params.loopResult.attempts,
+            changed_files: params.loopResult.changedFiles ?? [],
+            audit_path: params.loopResult.auditPath,
+            error_code: errorCode,
+            authorization_summary: params.loopResult.authorizationSummary,
+            usage: toUsage(params.loopResult),
+            authorization_decisions: toAuthorizationDecisions(params.loopResult),
+            structured_output_error: overrides?.structuredOutputError,
+            timestamps: {
+                started_at: params.startedAt.toISOString(),
+                ended_at: params.endedAt.toISOString(),
+            },
+            run_end: {
+                success,
+                exit_code: exitCode,
+                timestamp: params.endedAt.toISOString(),
+            },
+        },
+    };
+}
+export function encodeJsonFailure(params) {
+    const at = params.at ?? new Date();
+    const exitCode = params.exitCode ?? 1;
+    return {
+        result: '',
+        structured_output: null,
+        session_id: params.sessionId,
+        metadata: {
+            command: params.mode,
+            repo_path: params.repoPath,
+            instruction: params.instruction,
+            success: false,
+            exit_code: exitCode,
+            reason: params.message,
+            error_code: params.errorCode,
+            timestamps: {
+                started_at: at.toISOString(),
+                ended_at: at.toISOString(),
+            },
+        },
+    };
+}
+export function encodeJsonCrash(params) {
+    return {
+        result: '',
+        structured_output: null,
+        session_id: params.sessionId,
+        metadata: {
+            command: params.mode,
+            repo_path: params.repoPath,
+            instruction: params.instruction,
+            success: false,
+            exit_code: 1,
+            error: {
+                name: params.error.name,
+                message: params.error.message,
+                stack: params.error.stack,
+            },
+            timestamps: {
+                started_at: params.startedAt.toISOString(),
+                ended_at: params.endedAt.toISOString(),
+            },
+        },
+    };
+}
+//# sourceMappingURL=json-protocol.js.map