specrails-desktop 2.0.0

package/server/dist/proposal-manager.js

@@ -0,0 +1,291 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProposalManager = void 0;
+const readline_1 = require("readline");
+const tree_kill_1 = __importDefault(require("tree-kill"));
+const cli_prompt_1 = require("./util/cli-prompt");
+const db_1 = require("./db");
+const command_resolver_1 = require("./command-resolver");
+// ─── ProposalManager ──────────────────────────────────────────────────────────
+class ProposalManager {
+    _broadcast;
+    _db;
+    _cwd;
+    _activeProcesses;
+    _buffers;
+    _disposed = false;
+    constructor(broadcast, db, cwd) {
+        this._broadcast = broadcast;
+        this._db = db;
+        this._cwd = cwd;
+        this._activeProcesses = new Map();
+        this._buffers = new Map();
+    }
+    isActive(proposalId) {
+        return this._activeProcesses.has(proposalId);
+    }
+    /**
+     * Tear down before the project's DB is closed (M12). Disposes so in-flight
+     * close/error handlers skip their updateProposal DB writes (which would throw
+     * on the closed connection and crash the app), and SIGTERMs orphaned children.
+     */
+    shutdown() {
+        this._disposed = true;
+        for (const child of this._activeProcesses.values()) {
+            if (child.pid) {
+                try {
+                    (0, tree_kill_1.default)(child.pid, 'SIGTERM');
+                }
+                catch { /* ignore */ }
+            }
+        }
+        this._activeProcesses.clear();
+        this._buffers.clear();
+    }
+    async startExploration(proposalId, idea) {
+        const proposal = (0, db_1.getProposal)(this._db, proposalId);
+        if (!proposal) {
+            this._broadcastError(proposalId, 'Proposal not found');
+            return;
+        }
+        // Resolve the command file — error if not installed
+        const rawCommand = `/specrails:propose-feature ${idea}`;
+        const prompt = (0, command_resolver_1.resolveCommand)(rawCommand, this._cwd);
+        if (prompt === rawCommand) {
+            (0, db_1.updateProposal)(this._db, proposalId, { status: 'cancelled' });
+            this._broadcastError(proposalId, 'This project does not have the /specrails:propose-feature command installed. Run "npx specrails-core@latest" to update.');
+            return;
+        }
+        (0, db_1.updateProposal)(this._db, proposalId, { status: 'exploring' });
+        const args = [
+            '--dangerously-skip-permissions',
+            '--tools', 'default',
+            '--output-format', 'stream-json',
+            '--verbose',
+            '-p', prompt,
+        ];
+        await this._runProcess(proposalId, args, (fullText, sessionId) => {
+            (0, db_1.updateProposal)(this._db, proposalId, {
+                status: 'review',
+                result_markdown: fullText,
+                ...(sessionId ? { session_id: sessionId } : {}),
+            });
+            this._broadcast({
+                type: 'proposal_ready',
+                projectId: '',
+                proposalId,
+                markdown: fullText,
+                timestamp: new Date().toISOString(),
+            });
+        }, () => {
+            (0, db_1.updateProposal)(this._db, proposalId, { status: 'input' });
+            this._broadcastError(proposalId, 'Exploration failed');
+        });
+    }
+    async sendRefinement(proposalId, feedback) {
+        const proposal = (0, db_1.getProposal)(this._db, proposalId);
+        if (!proposal) {
+            this._broadcastError(proposalId, 'Proposal not found');
+            return;
+        }
+        if (!proposal.session_id) {
+            this._broadcastError(proposalId, 'No session available for refinement');
+            return;
+        }
+        (0, db_1.updateProposal)(this._db, proposalId, { status: 'refining' });
+        const args = [
+            '--dangerously-skip-permissions',
+            '--tools', 'default',
+            '--output-format', 'stream-json',
+            '--verbose',
+            '--resume', proposal.session_id,
+            '-p', feedback,
+        ];
+        await this._runProcess(proposalId, args, (fullText, sessionId) => {
+            (0, db_1.updateProposal)(this._db, proposalId, {
+                status: 'review',
+                result_markdown: fullText,
+                ...(sessionId ? { session_id: sessionId } : {}),
+            });
+            this._broadcast({
+                type: 'proposal_refined',
+                projectId: '',
+                proposalId,
+                markdown: fullText,
+                timestamp: new Date().toISOString(),
+            });
+        }, () => {
+            (0, db_1.updateProposal)(this._db, proposalId, { status: 'review' });
+            this._broadcastError(proposalId, 'Refinement failed');
+        });
+    }
+    async createIssue(proposalId) {
+        const proposal = (0, db_1.getProposal)(this._db, proposalId);
+        if (!proposal) {
+            this._broadcastError(proposalId, 'Proposal not found');
+            return;
+        }
+        if (!proposal.session_id) {
+            this._broadcastError(proposalId, 'No session available for issue creation');
+            return;
+        }
+        (0, db_1.updateProposal)(this._db, proposalId, { status: 'refining' });
+        const prompt = "Based on the proposal above, create a GitHub Issue with the label 'user-proposed'. " +
+            "Output only the URL of the created issue on the last line of your response.";
+        const args = [
+            '--dangerously-skip-permissions',
+            '--tools', 'default',
+            '--output-format', 'stream-json',
+            '--verbose',
+            '--resume', proposal.session_id,
+            '-p', prompt,
+        ];
+        await this._runProcess(proposalId, args, (fullText, sessionId) => {
+            const match = fullText.match(/https:\/\/github\.com\/[^\s]+\/issues\/\d+/);
+            const issueUrl = match ? match[0] : null;
+            if (issueUrl) {
+                (0, db_1.updateProposal)(this._db, proposalId, {
+                    status: 'created',
+                    issue_url: issueUrl,
+                    ...(sessionId ? { session_id: sessionId } : {}),
+                });
+                this._broadcast({
+                    type: 'proposal_issue_created',
+                    projectId: '',
+                    proposalId,
+                    issueUrl,
+                    timestamp: new Date().toISOString(),
+                });
+            }
+            else {
+                (0, db_1.updateProposal)(this._db, proposalId, { status: 'review' });
+                this._broadcastError(proposalId, 'Issue creation failed — GitHub CLI may not be available or not authenticated');
+            }
+        }, () => {
+            (0, db_1.updateProposal)(this._db, proposalId, { status: 'review' });
+            this._broadcastError(proposalId, 'Issue creation failed');
+        });
+    }
+    cancel(proposalId) {
+        const child = this._activeProcesses.get(proposalId);
+        if (child?.pid) {
+            (0, tree_kill_1.default)(child.pid, 'SIGTERM');
+        }
+        (0, db_1.updateProposal)(this._db, proposalId, { status: 'cancelled' });
+        this._broadcast({
+            type: 'proposal_error',
+            projectId: '',
+            proposalId,
+            error: 'cancelled',
+            timestamp: new Date().toISOString(),
+        });
+    }
+    // ─── Private helpers ───────────────────────────────────────────────────────
+    async _runProcess(proposalId, args, onSuccess, onError) {
+        // spawnClaude reroutes multi-line argv values through stdin on Windows.
+        const child = (0, cli_prompt_1.spawnClaude)(args, {
+            env: process.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            cwd: this._cwd,
+        });
+        this._activeProcesses.set(proposalId, child);
+        this._buffers.set(proposalId, '');
+        let capturedSessionId = null;
+        const stdoutReader = (0, readline_1.createInterface)({ input: child.stdout, crlfDelay: Infinity });
+        stdoutReader.on('line', (line) => {
+            let parsed = null;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch { /* skip non-JSON */ }
+            if (!parsed)
+                return;
+            const eventType = parsed.type;
+            if (eventType === 'result') {
+                const sid = parsed.session_id;
+                if (sid)
+                    capturedSessionId = sid;
+            }
+            if (eventType === 'assistant') {
+                const msg = parsed.message;
+                const blocks = msg?.content ?? [];
+                // Extract text from text blocks (skip thinking blocks)
+                const texts = blocks
+                    .filter((c) => c.type === 'text')
+                    .map((c) => c.text ?? '');
+                const newText = texts.join('');
+                if (newText) {
+                    const prev = this._buffers.get(proposalId) ?? '';
+                    this._buffers.set(proposalId, prev + newText);
+                    this._broadcast({
+                        type: 'proposal_stream',
+                        projectId: '',
+                        proposalId,
+                        delta: newText,
+                        timestamp: new Date().toISOString(),
+                    });
+                }
+                // Broadcast tool_use activity so the UI can show "reading codebase..."
+                for (const block of blocks) {
+                    if (block.type === 'tool_use' && block.name) {
+                        this._broadcast({
+                            type: 'proposal_stream',
+                            projectId: '',
+                            proposalId,
+                            delta: `<!--tool:${block.name}-->`,
+                            timestamp: new Date().toISOString(),
+                        });
+                    }
+                }
+            }
+        });
+        return new Promise((resolve) => {
+            // Without this handler an ENOENT on spawn (e.g. `claude` not on
+            // PATH) propagates as an unhandled 'error' event and crashes the
+            // entire app process. Surface to the user instead.
+            /* c8 ignore start -- spawn-failure path; exercised manually, not in CI */
+            child.on('error', (err) => {
+                console.error(`[ProposalManager] spawn failed for ${proposalId}: ${err.message}`);
+                this._activeProcesses.delete(proposalId);
+                this._buffers.delete(proposalId);
+                if (this._disposed) {
+                    resolve();
+                    return;
+                } // M12: project removed mid-flight; DB closing
+                this._broadcastError(proposalId, `Failed to launch claude: ${err.message}`);
+                onError();
+                resolve();
+            });
+            /* c8 ignore stop */
+            child.on('close', (code) => {
+                const fullText = this._buffers.get(proposalId) ?? '';
+                this._activeProcesses.delete(proposalId);
+                this._buffers.delete(proposalId);
+                if (this._disposed) {
+                    resolve();
+                    return;
+                } // M12: project removed mid-flight; DB closing
+                if (code === 0) {
+                    onSuccess(fullText, capturedSessionId);
+                }
+                else {
+                    onError();
+                }
+                resolve();
+            });
+        });
+    }
+    _broadcastError(proposalId, error) {
+        this._broadcast({
+            type: 'proposal_error',
+            projectId: '',
+            proposalId,
+            error,
+            timestamp: new Date().toISOString(),
+        });
+    }
+}
+exports.ProposalManager = ProposalManager;

package/server/dist/provider-selection.js

@@ -0,0 +1,69 @@
+"use strict";
+// Per-invocation provider selection for multi-provider projects.
+//
+// A project carries a primary `provider` (single source for single-provider
+// projects, and the fallback default) plus a `providers` list of every
+// installed provider. Add Spec, rails and the terminal can request a specific
+// engine per invocation; these helpers resolve and validate that request
+// against what the project actually has installed.
+//
+// Invariant: when `providers.length === 1` every helper collapses to the single
+// provider, so single-provider projects behave exactly as before.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isProviderEnabled = isProviderEnabled;
+exports.isMultiProvider = isMultiProvider;
+exports.resolveProvider = resolveProvider;
+exports.validateRequestedProvider = validateRequestedProvider;
+/**
+ * Normalised installed-provider list. `getProject` always populates
+ * `providers`, but this tolerates a row where it is missing/empty (legacy or
+ * hand-built rows) by falling back to the primary provider.
+ */
+function installedProviders(project) {
+    if (Array.isArray(project.providers) && project.providers.length > 0)
+        return project.providers;
+    return [project.provider ?? 'claude'];
+}
+/** True when `id` is one of the providers installed on the project. */
+function isProviderEnabled(project, id) {
+    if (!id)
+        return false;
+    return installedProviders(project).includes(id);
+}
+/** True when the project offers a choice of engines (more than one installed). */
+function isMultiProvider(project) {
+    return installedProviders(project).length > 1;
+}
+/**
+ * Resolve the effective provider for a per-invocation request.
+ * Returns the requested provider when it is installed on the project; otherwise
+ * falls back to the project's primary provider. Never throws — callers that
+ * want strict validation should use `validateRequestedProvider` first.
+ */
+function resolveProvider(project, requested) {
+    if (isProviderEnabled(project, requested))
+        return requested;
+    return project.provider ?? installedProviders(project)[0];
+}
+/**
+ * Strict validation for route handlers. Returns the resolved provider when the
+ * request is acceptable, or an `error` string when an explicit, non-empty
+ * provider was requested that the project does not have installed. Omitting the
+ * provider (undefined/null/empty) is always acceptable and resolves to primary.
+ */
+function validateRequestedProvider(project, requested) {
+    const installed = installedProviders(project);
+    if (requested === undefined || requested === null || requested === '') {
+        return { ok: true, provider: project.provider ?? installed[0] };
+    }
+    if (typeof requested !== 'string') {
+        return { ok: false, error: 'provider must be a string' };
+    }
+    if (!isProviderEnabled(project, requested)) {
+        return {
+            ok: false,
+            error: `provider '${requested}' is not installed for this project (installed: ${installed.join(', ')})`,
+        };
+    }
+    return { ok: true, provider: requested };
+}

package/server/dist/providers/claude-adapter.js

@@ -0,0 +1,281 @@
+"use strict";
+// Claude adapter. Ports the existing claude spawn / stream / result logic from
+// chat-manager.ts, queue-manager.ts, agent-refine-manager.ts,
+// project-router.ts (generate-spec), setup-manager.ts, and result-event.ts
+// without behaviour change. Managers will migrate to consume this adapter in
+// later tasks (see openspec/changes/add-multi-provider-support/tasks.md §2.x).
+//
+// Spec: openspec/specs/multi-provider-architecture/spec.md
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeAdapter = void 0;
+exports._normaliseClaudeModel = normaliseModel;
+const child_process_1 = require("child_process");
+const WHICH_CMD = process.platform === 'win32' ? 'where' : 'which';
+const CLAUDE_MODELS = [
+    { value: 'sonnet', label: 'Claude Sonnet', default: true },
+    { value: 'opus', label: 'Claude Opus' },
+    { value: 'haiku', label: 'Claude Haiku' },
+];
+/** Mirror of ChatManager.normalizeClaudeCodeModel — pinned model strings the
+ *  CLI accepts collapse to the short alias. */
+function normaliseModel(model) {
+    switch (model) {
+        case 'claude-sonnet-4-6':
+        case 'claude-sonnet-4-5':
+        case 'claude-sonnet-4-0':
+        case 'claude-sonnet-4-20250514':
+            return 'sonnet';
+        case 'claude-opus-4-8':
+        case 'claude-opus-4-5':
+        case 'claude-opus-4-1-20250805':
+        case 'claude-opus-4-20250514':
+            return 'opus';
+        case 'claude-haiku-4-5-20251001':
+        case 'claude-3-5-haiku-20241022':
+        case 'claude-3-5-haiku-latest':
+            return 'haiku';
+        default:
+            return model || 'sonnet';
+    }
+}
+/** Default arg block every claude spawn shares. */
+const COMMON_FLAGS = [
+    '--dangerously-skip-permissions',
+    '--tools', 'default',
+    '--output-format', 'stream-json',
+    '--verbose',
+    // Isolate app-spawned claude from the *user's* global Claude config. Without
+    // this, the child loads ~/.claude (user CLAUDE.md memory, plugins like
+    // claude-mem, SessionStart hooks). That bled cross-project memory into
+    // Explore turns (e.g. an unrelated "fighting game" surfaced for a fresh
+    // project) and inflated spec-gen tool usage past --max-turns. `project,local`
+    // still loads the target repo's own .claude settings + CLAUDE.md, which is
+    // exactly the context an app run should see.
+    '--setting-sources', 'project,local',
+];
+function buildClaudeArgs(action, opts) {
+    const args = [];
+    const model = normaliseModel(opts.model);
+    switch (action) {
+        case 'chat-turn': {
+            args.push('--model', model);
+            args.push(...COMMON_FLAGS);
+            if (opts.systemPrompt)
+                args.push('--system-prompt', opts.systemPrompt);
+            args.push('-p', opts.prompt);
+            if (opts.maxTurns != null)
+                args.push('--max-turns', String(opts.maxTurns));
+            if (opts.extraArgs)
+                args.push(...opts.extraArgs);
+            return args;
+        }
+        case 'chat-resume': {
+            if (!opts.sessionId) {
+                throw new Error('chat-resume requires sessionId');
+            }
+            args.push('--model', model);
+            args.push(...COMMON_FLAGS);
+            if (opts.systemPrompt)
+                args.push('--system-prompt', opts.systemPrompt);
+            args.push('--resume', opts.sessionId);
+            args.push('-p', opts.prompt);
+            if (opts.maxTurns != null)
+                args.push('--max-turns', String(opts.maxTurns));
+            if (opts.extraArgs)
+                args.push(...opts.extraArgs);
+            return args;
+        }
+        case 'rail-job': {
+            // QueueManager spawns with `--append-system-prompt` (not `--system-prompt`)
+            // because the slash command in the prompt brings its own system prompt;
+            // we ADD to it rather than overwrite.
+            args.push(...COMMON_FLAGS);
+            args.push('--model', model);
+            if (opts.systemPrompt)
+                args.push('--append-system-prompt', opts.systemPrompt);
+            args.push('-p', opts.prompt);
+            if (opts.extraArgs)
+                args.push(...opts.extraArgs);
+            return args;
+        }
+        case 'spec-gen': {
+            args.push(...COMMON_FLAGS);
+            args.push('--model', model);
+            if (opts.maxTurns != null)
+                args.push('--max-turns', String(opts.maxTurns));
+            // Caller passes --tools override via extraArgs when scoped; otherwise
+            // 'default' from COMMON_FLAGS applies.
+            if (opts.systemPrompt)
+                args.push('--system-prompt', opts.systemPrompt);
+            args.push('-p', opts.prompt);
+            if (opts.extraArgs)
+                args.push(...opts.extraArgs);
+            return args;
+        }
+        case 'agent-refine': {
+            args.push(...COMMON_FLAGS);
+            if (opts.sessionId)
+                args.push('--resume', opts.sessionId);
+            args.push('-p', opts.prompt);
+            if (opts.extraArgs)
+                args.push(...opts.extraArgs);
+            return args;
+        }
+        case 'setup-enrich': {
+            args.push('-p', opts.prompt);
+            args.push(...COMMON_FLAGS);
+            if (opts.extraArgs)
+                args.push(...opts.extraArgs);
+            return args;
+        }
+        case 'setup-enrich-resume': {
+            if (!opts.sessionId) {
+                throw new Error('setup-enrich-resume requires sessionId');
+            }
+            args.push('--resume', opts.sessionId);
+            args.push(...COMMON_FLAGS);
+            args.push('-p', opts.prompt);
+            if (opts.extraArgs)
+                args.push(...opts.extraArgs);
+            return args;
+        }
+        case 'auto-title': {
+            args.push(...COMMON_FLAGS);
+            args.push('-p', opts.prompt);
+            return args;
+        }
+    }
+}
+function parseClaudeStreamLine(line) {
+    if (line.length === 0)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    const type = parsed.type;
+    if (!type)
+        return { kind: 'other', type: '<missing>', raw: parsed };
+    if (type === 'system' || type === 'init') {
+        const sid = parsed.session_id ??
+            (parsed.session?.id ?? undefined);
+        if (sid)
+            return { kind: 'session-started', sessionId: sid };
+        return { kind: 'other', type, raw: parsed };
+    }
+    if (type === 'result') {
+        return { kind: 'result', payload: parsed };
+    }
+    if (type === 'assistant') {
+        const msg = parsed.message;
+        const blocks = msg?.content ?? [];
+        // Concatenate all text blocks; tool_use blocks are surfaced separately as a
+        // tool-use event. For simplicity we synthesise the first text block here
+        // and let callers consume tool_use from a fan-out (matching current
+        // chat-manager behaviour).
+        const text = blocks
+            .filter((b) => b.type === 'text')
+            .map((b) => b.text ?? '')
+            .join('');
+        if (text)
+            return { kind: 'text-delta', text };
+        // Surface a single tool-use (the historical pattern only emitted one per
+        // assistant frame anyway).
+        const tool = blocks.find((b) => b.type === 'tool_use');
+        if (tool?.name) {
+            const input = JSON.stringify(parsed.message?.content?.[0]?.input ?? {});
+            return { kind: 'tool-use', name: tool.name, inputPreview: input.slice(0, 200) };
+        }
+        return { kind: 'other', type, raw: parsed };
+    }
+    if (type === 'tool_use') {
+        const name = parsed.name ?? '<unnamed>';
+        const input = JSON.stringify(parsed.input ?? {});
+        return { kind: 'tool-use', name, inputPreview: input.slice(0, 200) };
+    }
+    return { kind: 'other', type, raw: parsed };
+}
+function extractClaudeResult(events) {
+    // Find the latest `result` event and the latest `session-started` event.
+    let resultPayload = null;
+    let sessionId;
+    for (const ev of events) {
+        if (ev.kind === 'result')
+            resultPayload = ev.payload;
+        else if (ev.kind === 'session-started')
+            sessionId = ev.sessionId;
+    }
+    if (!resultPayload)
+        return { session_id: sessionId };
+    const usage = resultPayload.usage;
+    // result event may also carry session_id directly — prefer that over the
+    // earlier captured one (it's authoritative for the final state).
+    const finalSessionId = resultPayload.session_id ?? sessionId;
+    return {
+        tokens_in: usage?.input_tokens,
+        tokens_out: usage?.output_tokens,
+        tokens_cache_read: usage?.cache_read_input_tokens,
+        tokens_cache_create: usage?.cache_creation_input_tokens,
+        total_cost_usd: resultPayload.total_cost_usd,
+        num_turns: resultPayload.num_turns,
+        model: resultPayload.model,
+        duration_ms: resultPayload.duration_ms,
+        duration_api_ms: resultPayload.api_duration_ms,
+        session_id: finalSessionId,
+    };
+}
+async function detectClaudeInstalled() {
+    let installed = false;
+    try {
+        (0, child_process_1.execSync)(`${WHICH_CMD} claude`, { stdio: 'ignore' });
+        installed = true;
+    }
+    catch {
+        return { installed: false, executable: false };
+    }
+    // Probe version for executability + reporting.
+    try {
+        const raw = (0, child_process_1.execSync)('claude --version', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'ignore'],
+            timeout: 3000,
+        }).trim();
+        const match = raw.match(/\d+\.\d+\.\d+[\w.-]*/);
+        return {
+            installed,
+            executable: true,
+            version: match ? match[0] : raw,
+            meetsMinimum: true, // claude has no pinned minimum in this adapter
+        };
+    }
+    catch {
+        return { installed, executable: false };
+    }
+}
+exports.claudeAdapter = {
+    id: 'claude',
+    displayName: 'Claude Code',
+    binary: 'claude',
+    minCliVersion: null,
+    projectDirName: '.claude',
+    instructionsFilename: 'CLAUDE.md',
+    mcpRegistration: 'project-json',
+    capabilities: {
+        nativeResume: true,
+        nativeStreamJson: true,
+        nativeCostUsd: true,
+        nativeOtelEnv: true,
+        profileEnvSupport: true,
+        systemPromptArg: true,
+    },
+    modelCatalog: () => CLAUDE_MODELS,
+    defaultModel: () => 'sonnet',
+    buildArgs: buildClaudeArgs,
+    parseStreamLine: parseClaudeStreamLine,
+    extractResult: extractClaudeResult,
+    baselineAgents: () => ['sr-architect', 'sr-developer', 'sr-reviewer'],
+    detectInstalled: detectClaudeInstalled,
+};