speckit-assistant 0.1.0

package/bin/adapters/secondary/agent/ProcessAgentRunner.js

@@ -0,0 +1,161 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessAgentRunner = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const PHASE_COMMANDS = {
+    constitution: '/speckit.constitution',
+    specification: '/speckit.specify',
+    clarification: '/speckit.clarify',
+    planning: '/speckit.plan',
+    checklist: '/speckit.checklist',
+    analyze: '/speckit.analyze',
+    tasks: '/speckit.tasks',
+    taskstoissues: '/speckit.taskstoissues',
+    implementation: '/speckit.implement',
+};
+class ProcessAgentRunner {
+    async runPhase(workspacePath, phase, featureName, agentConfig, userPrompt, onData) {
+        const specArg = phase !== 'constitution' && featureName ? `specs/${featureName}` : null;
+        const slashCmd = `${PHASE_COMMANDS[phase]}${specArg ? ` ${specArg}` : ''}`;
+        const context = userPrompt?.trim();
+        const fullPrompt = context ? `${context}\n\n${slashCmd}` : slashCmd;
+        const { cmd, args, stdin } = this.buildSpawnArgs(agentConfig, fullPrompt);
+        const isWin = process.platform === 'win32';
+        return new Promise((resolve) => {
+            onData?.(`Running: ${cmd} ${args.join(' ')}\n\n`);
+            const child = isWin
+                ? (0, child_process_1.spawn)(cmd, args, {
+                    cwd: workspacePath,
+                    shell: true,
+                    stdio: ['pipe', 'pipe', 'pipe']
+                })
+                : (() => {
+                    const shell = process.env.SHELL || '/bin/sh';
+                    const escapedArgs = [cmd, ...args].map(arg => `'${arg.replace(/'/g, "'\\''")}'`).join(' ');
+                    return (0, child_process_1.spawn)(shell, ['-l', '-c', escapedArgs], {
+                        cwd: workspacePath,
+                        stdio: ['pipe', 'pipe', 'pipe']
+                    });
+                })();
+            if (stdin !== undefined && child.stdin) {
+                child.stdin.write(stdin);
+                child.stdin.end();
+            }
+            child.stdout.on('data', (data) => {
+                const text = data.toString();
+                onData?.(text);
+            });
+            child.stderr.on('data', (data) => {
+                const text = data.toString();
+                onData?.(text);
+            });
+            child.on('close', (code) => {
+                const exitCode = code === null ? -1 : code;
+                onData?.(`\nProcess exited with code ${exitCode}\n`);
+                // Write the phase done file so local watch logs it
+                try {
+                    const runtimeDir = path.join(workspacePath, '.specify', '.runtime');
+                    if (!fs.existsSync(runtimeDir)) {
+                        fs.mkdirSync(runtimeDir, { recursive: true });
+                    }
+                    fs.writeFileSync(path.join(runtimeDir, 'phase-done.txt'), `${phase}:${exitCode}`, 'utf-8');
+                }
+                catch {
+                    // ignore
+                }
+                resolve(exitCode);
+            });
+            child.on('error', (err) => {
+                onData?.(`\nFailed to start process: ${err.message}\n`);
+                resolve(-1);
+            });
+        });
+    }
+    buildSpawnArgs(config, prompt) {
+        const agentType = config.agentType;
+        const cliPath = config.agentPath || this.getDefaultCli(agentType);
+        switch (agentType) {
+            case 'claude':
+                return {
+                    cmd: cliPath,
+                    args: ['--permission-mode', 'bypassPermissions', prompt]
+                };
+            case 'gemini':
+                return {
+                    cmd: cliPath,
+                    args: [],
+                    stdin: prompt
+                };
+            case 'copilot':
+                return {
+                    cmd: cliPath,
+                    args: [prompt]
+                };
+            case 'openai':
+                return {
+                    cmd: cliPath,
+                    args: ['exec', '-'],
+                    stdin: prompt
+                };
+            case 'custom':
+                if (config.customCommand) {
+                    const parts = config.customCommand.split(' ');
+                    const cmd = parts[0];
+                    const args = parts.slice(1).map(arg => arg === '{{prompt}}' ? prompt : arg);
+                    // If {{prompt}} isn't in args, append it
+                    if (!config.customCommand.includes('{{prompt}}')) {
+                        args.push(prompt);
+                    }
+                    return { cmd, args };
+                }
+                return { cmd: 'specify', args: [prompt] };
+            default:
+                return { cmd: cliPath, args: [prompt] };
+        }
+    }
+    getDefaultCli(agentType) {
+        const defaults = {
+            claude: 'claude',
+            gemini: 'gemini',
+            copilot: 'ghcs',
+            openai: 'codex'
+        };
+        return defaults[agentType] || 'specify';
+    }
+}
+exports.ProcessAgentRunner = ProcessAgentRunner;

package/bin/adapters/secondary/fs/FSWorkspaceRepository.js

@@ -0,0 +1,283 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FSWorkspaceRepository = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const FEATURE_PHASES = [
+    'specification',
+    'clarification',
+    'planning',
+    'checklist',
+    'analyze',
+    'tasks',
+    'taskstoissues',
+    'implementation'
+];
+class FSWorkspaceRepository {
+    async getWorkflowState(workspacePath) {
+        const state = this.loadStateFile(workspacePath) || this.defaultWorkflowState();
+        // 1. Reconcile Constitution
+        const constitutionPath = path.join(workspacePath, '.specify', 'memory', 'constitution.md');
+        if (fs.existsSync(constitutionPath)) {
+            state.constitutionPhase.filePath = constitutionPath;
+            state.constitutionPhase.content = fs.readFileSync(constitutionPath, 'utf-8');
+            if (state.constitutionPhase.status === 'idle') {
+                state.constitutionPhase.status = 'awaiting_review';
+            }
+        }
+        else {
+            state.constitutionPhase.filePath = null;
+            state.constitutionPhase.content = null;
+            state.constitutionPhase.status = 'idle';
+        }
+        // 2. Reconcile Features in specs/
+        const specsDir = path.join(workspacePath, 'specs');
+        if (fs.existsSync(specsDir)) {
+            const entries = fs.readdirSync(specsDir, { withFileTypes: true });
+            const foundFeatureNames = entries
+                .filter(e => e.isDirectory())
+                .map(e => e.name);
+            // Add newly found features that aren't in state
+            for (const name of foundFeatureNames) {
+                if (!state.features.some(f => f.name === name)) {
+                    state.features.push(this.makeFeatureWorkflow(name));
+                }
+            }
+            // Filter out deleted features
+            state.features = state.features.filter(f => foundFeatureNames.includes(f.name));
+            // Reconcile each feature's files
+            for (const feature of state.features) {
+                const fileMap = [
+                    { file: 'spec.md', phase: 'specification' },
+                    { file: 'plan.md', phase: 'planning' },
+                    { file: 'checklist.md', phase: 'checklist' },
+                    { file: 'analysis.md', phase: 'analyze' },
+                    { file: 'tasks.md', phase: 'tasks' }
+                ];
+                for (const { file, phase } of fileMap) {
+                    const fp = path.join(specsDir, feature.name, file);
+                    const ps = feature.phases.find(p => p.phase === phase);
+                    if (fs.existsSync(fp)) {
+                        ps.filePath = fp;
+                        ps.content = fs.readFileSync(fp, 'utf-8');
+                        if (ps.status === 'idle') {
+                            ps.status = 'awaiting_review';
+                        }
+                    }
+                    else {
+                        ps.filePath = null;
+                        ps.content = null;
+                        ps.status = 'idle';
+                    }
+                }
+                // Reconcile clarification (clarification.md or clarify.md)
+                const clarifyPhase = feature.phases.find(p => p.phase === 'clarification');
+                const clarifyPath1 = path.join(specsDir, feature.name, 'clarification.md');
+                const clarifyPath2 = path.join(specsDir, feature.name, 'clarify.md');
+                const finalClarifyPath = fs.existsSync(clarifyPath1) ? clarifyPath1 : (fs.existsSync(clarifyPath2) ? clarifyPath2 : null);
+                if (finalClarifyPath) {
+                    clarifyPhase.filePath = finalClarifyPath;
+                    clarifyPhase.content = fs.readFileSync(finalClarifyPath, 'utf-8');
+                    if (clarifyPhase.status === 'idle') {
+                        clarifyPhase.status = 'awaiting_review';
+                    }
+                }
+                else {
+                    clarifyPhase.filePath = null;
+                    clarifyPhase.content = null;
+                    clarifyPhase.status = 'idle';
+                }
+                // Implementation phase doesn't have its own file, but we can resolve its status.
+                // If specs/[feature]/tasks.md exists, and all checkboxes are checked, it could be complete.
+                // It relies on tasks status or manual review.
+                const implPhase = feature.phases.find(p => p.phase === 'implementation');
+                // Make sure its filePath is null (since there is no implementation.md file)
+                implPhase.filePath = null;
+                implPhase.content = null;
+            }
+        }
+        else {
+            state.features = [];
+        }
+        if (!state.activeFeatureName && state.features.length > 0) {
+            state.activeFeatureName = state.features[0].name;
+        }
+        return state;
+    }
+    async saveWorkflowState(workspacePath, state) {
+        const runtimeDir = path.join(workspacePath, '.specify', '.runtime');
+        if (!fs.existsSync(runtimeDir)) {
+            fs.mkdirSync(runtimeDir, { recursive: true });
+        }
+        const statePath = path.join(runtimeDir, 'workflow-state.json');
+        // We only save metadata (statuses and stale flag) to file to avoid writing bloated contents.
+        // Content is read dynamically from disk during reconciliation anyway.
+        const minimalState = {
+            constitutionPhase: {
+                phase: state.constitutionPhase.phase,
+                status: state.constitutionPhase.status,
+                stale: state.constitutionPhase.stale
+            },
+            features: state.features.map(f => ({
+                name: f.name,
+                phases: f.phases.map(p => ({
+                    phase: p.phase,
+                    status: p.status,
+                    stale: p.stale
+                }))
+            })),
+            activeFeatureName: state.activeFeatureName
+        };
+        fs.writeFileSync(statePath, JSON.stringify(minimalState, null, 2), 'utf-8');
+    }
+    async toggleTask(workspacePath, featureName, lineIndex, checked) {
+        const tasksPath = path.join(workspacePath, 'specs', featureName, 'tasks.md');
+        if (!fs.existsSync(tasksPath)) {
+            throw new Error(`Tasks file not found at ${tasksPath}`);
+        }
+        const content = fs.readFileSync(tasksPath, 'utf-8');
+        const lines = content.split('\n');
+        if (lineIndex < 0 || lineIndex >= lines.length) {
+            throw new Error(`Line index ${lineIndex} out of range`);
+        }
+        lines[lineIndex] = lines[lineIndex].replace(/^(\s*(?:[-*]|\d+\.)\s+\[)( |x|X)(\])/, (_, pre, _c, post) => `${pre}${checked ? 'x' : ' '}${post}`);
+        fs.writeFileSync(tasksPath, lines.join('\n'), 'utf-8');
+        // Return the updated state
+        return this.getWorkflowState(workspacePath);
+    }
+    async createFeature(workspacePath, name) {
+        const specsDir = path.join(workspacePath, 'specs');
+        const featureDir = path.join(specsDir, name);
+        if (!fs.existsSync(featureDir)) {
+            fs.mkdirSync(featureDir, { recursive: true });
+        }
+        // Try to run specify specify command or let the user do it via UI.
+        // We just create the directory. The files will be generated when the agent runs.
+        return this.getWorkflowState(workspacePath);
+    }
+    async deleteFeature(workspacePath, name) {
+        const featureDir = path.join(workspacePath, 'specs', name);
+        if (fs.existsSync(featureDir)) {
+            fs.rmSync(featureDir, { recursive: true, force: true });
+        }
+        const state = await this.getWorkflowState(workspacePath);
+        if (state.activeFeatureName === name) {
+            state.activeFeatureName = state.features.length > 0 ? state.features[0].name : null;
+        }
+        await this.saveWorkflowState(workspacePath, state);
+        return state;
+    }
+    async readFile(workspacePath, filePath) {
+        const absolutePath = path.isAbsolute(filePath) ? filePath : path.resolve(workspacePath, filePath);
+        if (!this.isPathSafe(workspacePath, absolutePath)) {
+            throw new Error('Access denied: Path is outside the workspace directory.');
+        }
+        if (!fs.existsSync(absolutePath)) {
+            return '';
+        }
+        return fs.readFileSync(absolutePath, 'utf-8');
+    }
+    async writeFile(workspacePath, filePath, content) {
+        const absolutePath = path.isAbsolute(filePath) ? filePath : path.resolve(workspacePath, filePath);
+        if (!this.isPathSafe(workspacePath, absolutePath)) {
+            throw new Error('Access denied: Path is outside the workspace directory.');
+        }
+        const dir = path.dirname(absolutePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(absolutePath, content, 'utf-8');
+    }
+    isPathSafe(workspacePath, absolutePath) {
+        const normWorkspace = path.normalize(workspacePath).replace(/\\/g, '/').toLowerCase();
+        const normAbsolute = path.normalize(absolutePath).replace(/\\/g, '/').toLowerCase();
+        if (normAbsolute === normWorkspace)
+            return true;
+        return normAbsolute.startsWith(normWorkspace.endsWith('/') ? normWorkspace : normWorkspace + '/');
+    }
+    // State initialization helpers
+    defaultWorkflowState() {
+        return {
+            constitutionPhase: { phase: 'constitution', status: 'idle', filePath: null, content: null },
+            features: [],
+            activeFeatureName: null
+        };
+    }
+    makePhaseState(phase) {
+        return { phase, status: 'idle', filePath: null, content: null };
+    }
+    makeFeatureWorkflow(name) {
+        return {
+            name,
+            phases: FEATURE_PHASES.map(p => this.makePhaseState(p))
+        };
+    }
+    loadStateFile(workspacePath) {
+        const statePath = path.join(workspacePath, '.specify', '.runtime', 'workflow-state.json');
+        if (!fs.existsSync(statePath)) {
+            return null;
+        }
+        try {
+            const payload = fs.readFileSync(statePath, 'utf-8');
+            const data = JSON.parse(payload);
+            // Merge with default formats
+            const state = this.defaultWorkflowState();
+            state.constitutionPhase.status = data.constitutionPhase?.status || 'idle';
+            state.constitutionPhase.stale = data.constitutionPhase?.stale || false;
+            if (Array.isArray(data.features)) {
+                state.features = data.features.map((f) => ({
+                    name: f.name,
+                    phases: FEATURE_PHASES.map(p => {
+                        const savedPhase = f.phases?.find((sp) => sp.phase === p);
+                        return {
+                            phase: p,
+                            status: savedPhase?.status || 'idle',
+                            stale: savedPhase?.stale || false,
+                            filePath: null,
+                            content: null
+                        };
+                    })
+                }));
+            }
+            state.activeFeatureName = data.activeFeatureName || null;
+            return state;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.FSWorkspaceRepository = FSWorkspaceRepository;

package/bin/app/api/feature/route.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = POST;
+exports.DELETE = DELETE;
+const server_1 = require("next/server");
+const di_1 = require("../../../adapters/di");
+const utils_1 = require("../../../adapters/primary/api/utils");
+async function POST(req) {
+    try {
+        const { name } = await req.json();
+        if (!name) {
+            return server_1.NextResponse.json({ error: 'Feature name is required' }, { status: 400 });
+        }
+        const workspacePath = (0, utils_1.getWorkspacePath)();
+        const state = await di_1.workflowService.createFeature(workspacePath, name);
+        return server_1.NextResponse.json(state);
+    }
+    catch (err) {
+        return server_1.NextResponse.json({ error: err.message }, { status: 500 });
+    }
+}
+async function DELETE(req) {
+    try {
+        const { name } = await req.json();
+        if (!name) {
+            return server_1.NextResponse.json({ error: 'Feature name is required' }, { status: 400 });
+        }
+        const workspacePath = (0, utils_1.getWorkspacePath)();
+        const state = await di_1.workflowService.deleteFeature(workspacePath, name);
+        return server_1.NextResponse.json(state);
+    }
+    catch (err) {
+        return server_1.NextResponse.json({ error: err.message }, { status: 500 });
+    }
+}

package/bin/app/api/file/route.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET = GET;
+exports.POST = POST;
+const server_1 = require("next/server");
+const di_1 = require("../../../adapters/di");
+const utils_1 = require("../../../adapters/primary/api/utils");
+async function GET(req) {
+    try {
+        const url = new URL(req.url);
+        const filePath = url.searchParams.get('path');
+        if (!filePath) {
+            return server_1.NextResponse.json({ error: 'Path is required' }, { status: 400 });
+        }
+        const workspacePath = (0, utils_1.getWorkspacePath)();
+        const content = await di_1.workflowService.readFile(workspacePath, filePath);
+        return server_1.NextResponse.json({ path: filePath, content });
+    }
+    catch (err) {
+        return server_1.NextResponse.json({ error: err.message }, { status: 500 });
+    }
+}
+async function POST(req) {
+    try {
+        const { path: filePath, content } = await req.json();
+        if (!filePath || content === undefined) {
+            return server_1.NextResponse.json({ error: 'Path and content are required' }, { status: 400 });
+        }
+        const workspacePath = (0, utils_1.getWorkspacePath)();
+        const state = await di_1.workflowService.writeFile(workspacePath, filePath, content);
+        return server_1.NextResponse.json({ success: true, state });
+    }
+    catch (err) {
+        return server_1.NextResponse.json({ error: err.message }, { status: 500 });
+    }
+}

package/bin/app/api/phase/route.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = POST;
+const server_1 = require("next/server");
+const di_1 = require("../../../adapters/di");
+const utils_1 = require("../../../adapters/primary/api/utils");
+async function POST(req) {
+    try {
+        const { action, phase, featureName, agentConfig, prompt } = await req.json();
+        if (!action || !phase) {
+            return server_1.NextResponse.json({ error: 'Missing action or phase' }, { status: 400 });
+        }
+        const workspacePath = (0, utils_1.getWorkspacePath)();
+        if (action === 'approve') {
+            const state = await di_1.workflowService.approvePhase(workspacePath, phase, featureName);
+            return server_1.NextResponse.json(state);
+        }
+        if (action === 'discard') {
+            const state = await di_1.workflowService.discardPhase(workspacePath, phase, featureName);
+            return server_1.NextResponse.json(state);
+        }
+        if (action === 'run') {
+            const encoder = new TextEncoder();
+            const customReadableStream = new ReadableStream({
+                async start(controller) {
+                    const sendEvent = (event, data) => {
+                        controller.enqueue(encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`));
+                    };
+                    try {
+                        const finalState = await di_1.workflowService.runPhase(workspacePath, phase, featureName, agentConfig, prompt, (text) => {
+                            sendEvent('log', { text });
+                        });
+                        sendEvent('done', { state: finalState });
+                        controller.close();
+                    }
+                    catch (err) {
+                        sendEvent('error', { message: err.message });
+                        controller.close();
+                    }
+                }
+            });
+            return new Response(customReadableStream, {
+                headers: {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    'Connection': 'keep-alive',
+                }
+            });
+        }
+        return server_1.NextResponse.json({ error: 'Invalid action' }, { status: 400 });
+    }
+    catch (err) {
+        return server_1.NextResponse.json({ error: err.message }, { status: 500 });
+    }
+}

package/bin/app/api/state/route.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET = GET;
+exports.POST = POST;
+const server_1 = require("next/server");
+const di_1 = require("../../../adapters/di");
+const utils_1 = require("../../../adapters/primary/api/utils");
+async function GET() {
+    try {
+        const workspacePath = (0, utils_1.getWorkspacePath)();
+        const state = await di_1.workflowService.getWorkflowState(workspacePath);
+        return server_1.NextResponse.json(state);
+    }
+    catch (err) {
+        return server_1.NextResponse.json({ error: err.message }, { status: 500 });
+    }
+}
+async function POST(req) {
+    try {
+        const { activeFeatureName } = await req.json();
+        const workspacePath = (0, utils_1.getWorkspacePath)();
+        const state = await di_1.workflowService.setActiveFeature(workspacePath, activeFeatureName);
+        return server_1.NextResponse.json(state);
+    }
+    catch (err) {
+        return server_1.NextResponse.json({ error: err.message }, { status: 500 });
+    }
+}