speckit-assistant 0.1.0

package/bin/domain/services/WorkflowService.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowService = void 0;
+const FEATURE_PHASES = [
+    'specification',
+    'clarification',
+    'planning',
+    'checklist',
+    'analyze',
+    'tasks',
+    'taskstoissues',
+    'implementation'
+];
+class WorkflowService {
+    workspaceRepo;
+    agentRunner;
+    constructor(workspaceRepo, agentRunner) {
+        this.workspaceRepo = workspaceRepo;
+        this.agentRunner = agentRunner;
+    }
+    async getWorkflowState(workspacePath) {
+        const state = await this.workspaceRepo.getWorkflowState(workspacePath);
+        return state;
+    }
+    async createFeature(workspacePath, name) {
+        const state = await this.workspaceRepo.createFeature(workspacePath, name);
+        state.activeFeatureName = name;
+        await this.workspaceRepo.saveWorkflowState(workspacePath, state);
+        return state;
+    }
+    async deleteFeature(workspacePath, name) {
+        const state = await this.workspaceRepo.deleteFeature(workspacePath, name);
+        return state;
+    }
+    async setActiveFeature(workspacePath, name) {
+        const state = await this.workspaceRepo.getWorkflowState(workspacePath);
+        if (state.features.some(f => f.name === name)) {
+            state.activeFeatureName = name;
+            await this.workspaceRepo.saveWorkflowState(workspacePath, state);
+        }
+        return state;
+    }
+    async runPhase(workspacePath, phase, featureName, agentConfig, userPrompt, onData) {
+        const state = await this.workspaceRepo.getWorkflowState(workspacePath);
+        const targetFeature = featureName || state.activeFeatureName;
+        // Set status to running
+        this.setPhaseStatus(state, phase, targetFeature, 'running');
+        await this.workspaceRepo.saveWorkflowState(workspacePath, state);
+        try {
+            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 {
+                this.setPhaseStatus(freshState, phase, targetFeature, 'idle');
+            }
+            // Check if tasks are completed to auto-complete implementation
+            if (phase === 'implementation') {
+                await this.checkImplementationAutoReview(workspacePath, freshState, targetFeature);
+            }
+            await this.workspaceRepo.saveWorkflowState(workspacePath, freshState);
+            return freshState;
+        }
+        catch (err) {
+            const freshState = await this.workspaceRepo.getWorkflowState(workspacePath);
+            this.setPhaseStatus(freshState, phase, targetFeature, 'idle');
+            await this.workspaceRepo.saveWorkflowState(workspacePath, freshState);
+            throw err;
+        }
+    }
+    async approvePhase(workspacePath, phase, featureName) {
+        const state = await this.workspaceRepo.getWorkflowState(workspacePath);
+        const targetFeature = featureName || state.activeFeatureName;
+        const ps = this.findPhase(state, phase, targetFeature);
+        if (ps) {
+            ps.status = 'approved';
+            ps.stale = false;
+        }
+        await this.workspaceRepo.saveWorkflowState(workspacePath, state);
+        return state;
+    }
+    async discardPhase(workspacePath, phase, featureName) {
+        const state = await this.workspaceRepo.getWorkflowState(workspacePath);
+        const targetFeature = featureName || state.activeFeatureName;
+        const ps = this.findPhase(state, phase, targetFeature);
+        if (ps) {
+            ps.status = 'idle';
+            ps.content = null;
+            ps.stale = false;
+        }
+        this.markDownstreamStale(state, phase, targetFeature);
+        await this.workspaceRepo.saveWorkflowState(workspacePath, state);
+        return state;
+    }
+    async toggleTask(workspacePath, featureName, lineIndex, checked) {
+        const freshState = await this.workspaceRepo.toggleTask(workspacePath, featureName, lineIndex, checked);
+        await this.checkImplementationAutoReview(workspacePath, freshState, featureName);
+        await this.workspaceRepo.saveWorkflowState(workspacePath, freshState);
+        return freshState;
+    }
+    async readFile(workspacePath, filePath) {
+        return this.workspaceRepo.readFile(workspacePath, filePath);
+    }
+    async writeFile(workspacePath, filePath, content) {
+        await this.workspaceRepo.writeFile(workspacePath, filePath, content);
+        // Determine which phase/feature this file belongs to and update status to awaiting_review if not approved
+        const state = await this.workspaceRepo.getWorkflowState(workspacePath);
+        await this.workspaceRepo.saveWorkflowState(workspacePath, state);
+        return state;
+    }
+    // Helper methods
+    findPhase(state, phase, featureName) {
+        if (phase === 'constitution') {
+            return state.constitutionPhase;
+        }
+        const feature = state.features.find(f => f.name === featureName);
+        if (!feature)
+            return null;
+        return feature.phases.find(p => p.phase === phase) || null;
+    }
+    setPhaseStatus(state, phase, featureName, status) {
+        const ps = this.findPhase(state, phase, featureName);
+        if (ps) {
+            ps.status = status;
+        }
+    }
+    markDownstreamStale(state, discarded, featureName) {
+        if (discarded === 'constitution') {
+            for (const feature of state.features) {
+                for (const p of feature.phases) {
+                    if (p.status === 'approved')
+                        p.stale = true;
+                }
+            }
+            return;
+        }
+        const feature = state.features.find(f => f.name === featureName);
+        if (!feature)
+            return;
+        const idx = FEATURE_PHASES.indexOf(discarded);
+        if (idx === -1)
+            return;
+        for (let i = idx + 1; i < FEATURE_PHASES.length; i++) {
+            const later = feature.phases.find(p => p.phase === FEATURE_PHASES[i]);
+            if (later && later.status === 'approved') {
+                later.stale = true;
+            }
+        }
+    }
+    async checkImplementationAutoReview(workspacePath, state, featureName) {
+        const feature = state.features.find(f => f.name === featureName);
+        if (!feature)
+            return;
+        const tasksPhase = feature.phases.find(p => p.phase === 'tasks');
+        const implPhase = feature.phases.find(p => p.phase === 'implementation');
+        if (!tasksPhase?.filePath || !implPhase)
+            return;
+        try {
+            const content = await this.workspaceRepo.readFile(workspacePath, tasksPhase.filePath);
+            const checkboxes = [...content.matchAll(/^\s*(?:[-*]|\d+\.)\s+\[( |x|X)\]/gm)];
+            if (checkboxes.length > 0 && checkboxes.every(c => c[1].toLowerCase() === 'x')) {
+                if (implPhase.status === 'running' || implPhase.status === 'idle') {
+                    implPhase.status = 'awaiting_review';
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+exports.WorkflowService = WorkflowService;

package/next.config.ts

@@ -0,0 +1,13 @@
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  reactStrictMode: true,
+  eslint: {
+    ignoreDuringBuilds: true,
+  },
+  typescript: {
+    ignoreBuildErrors: true,
+  }
+};
+
+export default nextConfig;

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "speckit-assistant",
+  "version": "0.1.0",
+  "description": "Visual orchestrator for Spec-Driven Development (SDD) — Next.js, ReactFlow and Hexagonal Architecture",
+  "main": "dist/index.js",
+  "bin": {
+    "speckit-assistant": "./bin/bin/cli.js"
+  },
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build && tsc -p tsconfig.bin.json",
+    "start": "next start",
+    "test": "vitest run",
+    "prepublishOnly": "pnpm run build"
+  },
+  "files": [
+    "bin",
+    ".next",
+    "next.config.ts"
+  ],
+  "keywords": [
+    "sdd",
+    "speckit",
+    "nextjs",
+    "reactflow",
+    "hexagonal-architecture"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@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",
+    "open": "^10.1.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "tailwind-merge": "^2.5.5"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.9",
+    "@types/react": "^19.0.1",
+    "@types/react-dom": "^19.0.2",
+    "@vitest/coverage-v8": "^2.1.9",
+    "autoprefixer": "^10.4.20",
+    "postcss": "^8.4.49",
+    "tailwindcss": "^3.4.16",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  }
+}