speckit-assistant 0.1.2 → 0.1.4

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

@@ -6,7 +6,7 @@ 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();
+        const { action, phase, featureName, agentConfig, prompt, text, cols, rows, personaId, personas } = await req.json();
         if (!action || !phase) {
             return server_1.NextResponse.json({ error: 'Missing action or phase' }, { status: 400 });
         }
@@ -19,7 +19,19 @@ async function POST(req) {
             const state = await di_1.workflowService.discardPhase(workspacePath, phase, featureName);
             return server_1.NextResponse.json(state);
         }
-        if (action === 'run') {
+        if (action === 'input') {
+            const success = await di_1.workflowService.writeStdin(phase, featureName, text, personaId);
+            return server_1.NextResponse.json({ success });
+        }
+        if (action === 'resize') {
+            const success = await di_1.workflowService.resize(phase, featureName, cols, rows, personaId);
+            return server_1.NextResponse.json({ success });
+        }
+        if (action === 'stop') {
+            const success = await di_1.workflowService.stop(phase, featureName, personaId);
+            return server_1.NextResponse.json({ success });
+        }
+        if (action === 'run' || action === 'run-gate') {
             const encoder = new TextEncoder();
             const customReadableStream = new ReadableStream({
                 async start(controller) {
@@ -27,9 +39,10 @@ async function POST(req) {
                         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 });
-                        });
+                        const onData = (t) => sendEvent('log', { text: t });
+                        const finalState = action === 'run-gate'
+                            ? await di_1.workflowService.runImplementationGate(workspacePath, featureName, agentConfig, (personas ?? []), onData)
+                            : await di_1.workflowService.runPhase(workspacePath, phase, featureName, agentConfig, prompt, onData, personas);
                         sendEvent('done', { state: finalState });
                         controller.close();
                     }

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

@@ -71,8 +71,13 @@ async function GET() {
             };
             // Watch all change events (add, change, unlink)
             watcher.on('all', (event, filePath) => {
-                // Skip changes inside the internal runtime state directory
-                if (filePath.includes('.runtime') || filePath.includes('.git'))
+                if (filePath.includes('.git'))
+                    return;
+                // The internal runtime dir is otherwise noisy, but workflow-state.json
+                // holds the phase statuses (e.g. 'running'), so let that one through —
+                // it's what tells the Kanban a phase is executing. getWorkflowState is
+                // read-only, so re-emitting on it cannot create a write/watch loop.
+                if (filePath.includes('.runtime') && !filePath.includes('workflow-state.json'))
                     return;
                 sendUpdate(filePath);
             });

package/bin/app/api/terminal/input/route.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = POST;
+const server_1 = require("next/server");
+const terminalManager_1 = require("../../../../adapters/primary/api/terminalManager");
+async function POST(req) {
+    try {
+        const { text } = await req.json();
+        if (text === undefined) {
+            return server_1.NextResponse.json({ error: 'Missing text input' }, { status: 400 });
+        }
+        const success = terminalManager_1.terminalManager.writeInput(text);
+        return server_1.NextResponse.json({ success });
+    }
+    catch (err) {
+        return server_1.NextResponse.json({ error: err.message }, { status: 500 });
+    }
+}

package/bin/app/api/terminal/resize/route.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = POST;
+const server_1 = require("next/server");
+const terminalManager_1 = require("../../../../adapters/primary/api/terminalManager");
+async function POST(req) {
+    try {
+        const { cols, rows } = await req.json();
+        if (typeof cols !== 'number' || typeof rows !== 'number') {
+            return server_1.NextResponse.json({ error: 'cols and rows must be numbers' }, { status: 400 });
+        }
+        const success = terminalManager_1.terminalManager.resize(cols, rows);
+        return server_1.NextResponse.json({ success });
+    }
+    catch (err) {
+        return server_1.NextResponse.json({ error: err.message }, { status: 500 });
+    }
+}

package/bin/app/api/terminal/stream/route.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dynamic = void 0;
+exports.GET = GET;
+const terminalManager_1 = require("../../../../adapters/primary/api/terminalManager");
+exports.dynamic = 'force-dynamic';
+async function GET() {
+    const encoder = new TextEncoder();
+    let listener = null;
+    let interval = null;
+    const stream = new ReadableStream({
+        start(controller) {
+            listener = (data) => {
+                controller.enqueue(encoder.encode(`data: ${JSON.stringify({ output: data })}\n\n`));
+            };
+            terminalManager_1.terminalManager.addListener(listener);
+            // Keep-alive heartbeat to prevent gateway timeouts
+            interval = setInterval(() => {
+                try {
+                    controller.enqueue(encoder.encode(': heartbeat\n\n'));
+                }
+                catch {
+                    // ignore
+                }
+            }, 15000);
+        },
+        cancel() {
+            if (interval) {
+                clearInterval(interval);
+            }
+            if (listener) {
+                terminalManager_1.terminalManager.removeListener(listener);
+            }
+        }
+    });
+    return new Response(stream, {
+        headers: {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache, no-transform',
+            'Connection': 'keep-alive',
+            'X-Accel-Buffering': 'no'
+        }
+    });
+}

package/bin/domain/models/personas.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PERSONAS = exports.PERSONA_ORDER = void 0;
+exports.personaReportPath = personaReportPath;
+exports.orderPersonas = orderPersonas;
+// Fixed execution order of the implementation review gate. Tech Lead runs last
+// so it can aggregate the findings of the preceding personas and sign off.
+exports.PERSONA_ORDER = ['qa', 'code-review', 'security', 'tech-lead'];
+// Default persona registry. Each persona is backed by a Spec Kit extension
+// slash command (see extensions/spec-kit-personas). Users can override the
+// command or disable a persona from the Agent Config UI.
+exports.DEFAULT_PERSONAS = [
+    {
+        id: 'qa',
+        label: 'QA',
+        command: '/speckit.review.qa',
+        enabled: true,
+        model: 'gemini-2.5-flash',
+        description: 'Automated quality assurance agent. Runs tests, verifies regression suite, and inspects validation logs.',
+        systemPrompt: 'You are the QA persona in a Spec-Driven Development cycle. Your goal is to run unit/integration tests and check that code changes do not break existing features. Output verification reports with a clear VERDICT: PASS or FAIL.',
+        capabilities: ['Runs Vitest/Jest test suites', 'Generates coverage reports', 'Checks edge cases in inputs', 'Identifies code regressions'],
+        tools: ['vitest', 'npm test', 'coverage-reporter', 'test-generator']
+    },
+    {
+        id: 'code-review',
+        label: 'Code Review',
+        command: '/speckit.review.code',
+        enabled: true,
+        model: 'gemini-2.5-pro',
+        description: 'Automated code standard and architectural reviewer. Validates SOLID patterns and code complexity.',
+        systemPrompt: 'You are the Code Reviewer persona. Analyze source code diffs for adherence to architectural standards, clean code practices (SOLID, DRY), and formatting. Output feedback with a final VERDICT: PASS or FAIL.',
+        capabilities: ['Analyzes design pattern compliance', 'Checks cyclomatic complexity', 'Identifies redundant code blocks', 'Ensures type safety'],
+        tools: ['eslint', 'typescript-compiler', 'complexity-analyzer', 'stylelint']
+    },
+    {
+        id: 'security',
+        label: 'Security',
+        command: '/speckit.review.security',
+        enabled: true,
+        model: 'claude-3-5-sonnet',
+        description: 'Automated security compliance agent. Scans for hardcoded credentials, dependency CVEs, and OWASP vulnerabilities.',
+        systemPrompt: 'You are the Security Auditor persona. Scan changes for exposed credentials, API keys, dependency vulnerabilities, injection flaws, and other OWASP Top 10 risks. Output a final VERDICT: PASS or FAIL.',
+        capabilities: ['Scans for exposed secrets', 'Identifies dependency CVEs', 'Detects injection vulnerabilities', 'Verifies authentication protocols'],
+        tools: ['git-secrets', 'npm audit', 'owasp-scanner', 'trivy']
+    },
+    {
+        id: 'tech-lead',
+        label: 'Tech Lead',
+        command: '/speckit.review.techlead',
+        enabled: true,
+        model: 'gemini-2.5-pro',
+        description: 'Tech Lead agent responsible for final signature sign-off. Aggregates reviews and signs the implementation gate.',
+        systemPrompt: 'You are the Tech Lead persona. You represent the final automated validation step. Aggregate findings from previous agents, confirm architecture completeness, and sign the gate. Output a final VERDICT: PASS or FAIL.',
+        capabilities: ['Aggregates reviews and signals', 'Confirms architecture patterns', 'Approves merge readiness', 'Performs final API signature verification'],
+        tools: ['git-merge-dryrun', 'dependency-checker', 'signature-verifier']
+    }
+];
+// Relative path (from the feature dir) where a persona writes its review report.
+function personaReportPath(featureName, id) {
+    return `specs/${featureName}/reviews/${id}.md`;
+}
+// Sort an arbitrary persona list into the canonical gate order.
+function orderPersonas(personas) {
+    return [...personas].sort((a, b) => exports.PERSONA_ORDER.indexOf(a.id) - exports.PERSONA_ORDER.indexOf(b.id));
+}

package/bin/domain/services/WorkflowService.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkflowService = void 0;
+const personas_1 = require("../models/personas");
 const FEATURE_PHASES = [
     'specification',
     'clarification',
@@ -40,7 +41,7 @@ class WorkflowService {
         }
         return state;
     }
-    async runPhase(workspacePath, phase, featureName, agentConfig, userPrompt, onData) {
+    async runPhase(workspacePath, phase, featureName, agentConfig, userPrompt, onData, personas) {
         const state = await this.workspaceRepo.getWorkflowState(workspacePath);
         const targetFeature = featureName || state.activeFeatureName;
         // Set status to running
@@ -50,12 +51,20 @@ class WorkflowService {
             const exitCode = await this.agentRunner.runPhase(workspacePath, phase, targetFeature, agentConfig, userPrompt, onData);
             // Re-read state in case files changed on disk during run
             const freshState = await this.workspaceRepo.getWorkflowState(workspacePath);
-            if (exitCode === 0) {
-                this.setPhaseStatus(freshState, phase, targetFeature, 'awaiting_review');
-            }
-            else {
+            if (exitCode !== 0) {
                 this.setPhaseStatus(freshState, phase, targetFeature, 'idle');
+                await this.workspaceRepo.saveWorkflowState(workspacePath, freshState);
+                return freshState;
+            }
+            // Implementation: if a review gate is configured, the personas govern the
+            // final status (only reaching awaiting_review after Tech Lead signs off).
+            const enabledPersonas = (personas ?? []).filter(p => p.enabled);
+            if (phase === 'implementation' && targetFeature && enabledPersonas.length > 0) {
+                this.setPhaseStatus(freshState, phase, targetFeature, 'running');
+                await this.workspaceRepo.saveWorkflowState(workspacePath, freshState);
+                return this.runImplementationGate(workspacePath, targetFeature, agentConfig, personas, onData);
             }
+            this.setPhaseStatus(freshState, phase, targetFeature, 'awaiting_review');
             // Check if tasks are completed to auto-complete implementation
             if (phase === 'implementation') {
                 await this.checkImplementationAutoReview(workspacePath, freshState, targetFeature);
@@ -70,6 +79,62 @@ class WorkflowService {
             throw err;
         }
     }
+    // Runs the implementation review gate: enabled personas execute sequentially
+    // (Tech Lead last). The gate stops at the first persona that fails, leaving
+    // the implementation phase 'running' (blocked). Only when every persona passes
+    // does the phase advance to 'awaiting_review' for human approval.
+    async runImplementationGate(workspacePath, featureName, agentConfig, personas, onData) {
+        const enabled = (0, personas_1.orderPersonas)(personas.filter(p => p.enabled));
+        const state = await this.workspaceRepo.getWorkflowState(workspacePath);
+        const implPhase = this.findPhase(state, 'implementation', featureName);
+        if (!implPhase)
+            return state;
+        implPhase.status = 'running';
+        implPhase.personas = enabled.map(p => ({
+            id: p.id,
+            status: 'idle',
+            reportPath: (0, personas_1.personaReportPath)(featureName, p.id),
+        }));
+        await this.workspaceRepo.saveWorkflowState(workspacePath, state);
+        for (const persona of enabled) {
+            const ps = implPhase.personas.find(x => x.id === persona.id);
+            ps.status = 'running';
+            await this.workspaceRepo.saveWorkflowState(workspacePath, state);
+            onData?.(`\r\n\x1b[36m=== Persona: ${persona.label} (${persona.command}) ===\x1b[0m\r\n`);
+            const exitCode = await this.agentRunner.runPersona(workspacePath, featureName, persona, agentConfig, onData);
+            const verdict = await this.resolvePersonaVerdict(workspacePath, featureName, persona.id, exitCode);
+            ps.status = verdict;
+            await this.workspaceRepo.saveWorkflowState(workspacePath, state);
+            if (verdict === 'failed') {
+                onData?.(`\r\n\x1b[31m✗ ${persona.label} bloqueou o gate — implementação permanece em revisão.\x1b[0m\r\n`);
+                return state;
+            }
+            onData?.(`\r\n\x1b[32m✓ ${persona.label} passou.\x1b[0m\r\n`);
+        }
+        implPhase.status = 'awaiting_review';
+        await this.workspaceRepo.saveWorkflowState(workspacePath, state);
+        onData?.(`\r\n\x1b[32m✓ Review gate completo — pronto para aprovação.\x1b[0m\r\n`);
+        return state;
+    }
+    // A persona's verdict is read from its report (specs/<feature>/reviews/<id>.md):
+    // an explicit "VERDICT: PASS|FAIL" marker wins; otherwise we fall back to the
+    // process exit code. This is robust across heterogeneous agent CLIs that may
+    // not control their exit code reliably.
+    async resolvePersonaVerdict(workspacePath, featureName, id, exitCode) {
+        let report = '';
+        try {
+            report = await this.workspaceRepo.readFile(workspacePath, (0, personas_1.personaReportPath)(featureName, id));
+        }
+        catch {
+            report = '';
+        }
+        const text = report.toUpperCase();
+        if (/VERDICT:\s*FAIL/.test(text))
+            return 'failed';
+        if (/VERDICT:\s*PASS/.test(text))
+            return 'passed';
+        return exitCode === 0 ? 'passed' : 'failed';
+    }
     async approvePhase(workspacePath, phase, featureName) {
         const state = await this.workspaceRepo.getWorkflowState(workspacePath);
         const targetFeature = featureName || state.activeFeatureName;
@@ -110,6 +175,15 @@ class WorkflowService {
         await this.workspaceRepo.saveWorkflowState(workspacePath, state);
         return state;
     }
+    async writeStdin(phase, featureName, text, personaId) {
+        return this.agentRunner.writeStdin(phase, featureName, text, personaId);
+    }
+    async resize(phase, featureName, cols, rows, personaId) {
+        return this.agentRunner.resize(phase, featureName, cols, rows, personaId);
+    }
+    async stop(phase, featureName, personaId) {
+        return this.agentRunner.stop(phase, featureName, personaId);
+    }
     // Helper methods
     findPhase(state, phase, featureName) {
         if (phase === 'constitution') {

package/next.config.mjs

@@ -0,0 +1,15 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  reactStrictMode: true,
+  // node-pty is a native addon and must not be bundled by webpack; load it from
+  // node_modules at runtime on the server instead.
+  serverExternalPackages: ['node-pty'],
+  eslint: {
+    ignoreDuringBuilds: true,
+  },
+  typescript: {
+    ignoreBuildErrors: true,
+  }
+};
+
+export default nextConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "speckit-assistant",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Visual orchestrator for Spec-Driven Development (SDD) — Next.js, ReactFlow and Hexagonal Architecture",
   "main": "dist/index.js",
   "bin": {
@@ -16,7 +16,7 @@
   "files": [
     "bin",
     ".next",
-    "next.config.ts"
+    "next.config.mjs"
   ],
   "keywords": [
     "sdd",
@@ -35,13 +35,21 @@
     "url": "https://github.com/dmux/speckit-assistant/issues"
   },
   "homepage": "https://github.com/dmux/speckit-assistant#readme",
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "node-pty"
+    ]
+  },
   "dependencies": {
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/xterm": "^6.0.0",
     "@xyflow/react": "^12.3.5",
     "chokidar": "^5.0.0",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "lucide-react": "^0.468.0",
     "next": "^15.1.0",
+    "node-pty": "^1.1.0",
     "open": "^10.1.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",

package/.next/static/QraS9_bCyr2_QD3cQIBT8/_buildManifest.js

@@ -1 +0,0 @@
-self.__BUILD_MANIFEST=function(e,r,t){return{__rewrites:{afterFiles:[],beforeFiles:[],fallback:[]},__routerFilterStatic:{numItems:8,errorRate:1e-4,numBits:154,numHashes:14,bitArray:[0,0,e,1,1,e,e,r,e,r,e,r,r,r,r,e,r,r,r,e,r,e,r,r,r,e,e,r,e,e,r,r,e,e,e,e,r,e,r,e,e,e,e,r,r,e,r,e,e,e,r,e,r,e,r,r,e,r,e,r,e,e,r,r,e,r,e,r,e,r,r,e,e,r,e,r,r,r,r,r,r,e,r,r,e,r,e,r,r,r,e,e,r,r,e,e,e,e,r,r,e,e,r,e,r,r,e,e,e,e,e,r,e,e,e,e,r,e,r,e,r,e,r,e,r,e,r,e,e,r,r,e,r,e,e,r,e,e,e,r,r,e,e,r,r,r,r,r,e,r,e,r,r,r]},__routerFilterDynamic:{numItems:e,errorRate:1e-4,numBits:e,numHashes:null,bitArray:[]},"/_error":["static/chunks/pages/_error-78b0b3b591df0e73.js"],sortedPages:["/_app","/_error"]}}(0,1,1e-4),self.__BUILD_MANIFEST_CB&&self.__BUILD_MANIFEST_CB();