@aicoffe/ai-native-sdlc-mcp 0.1.0

package/dist/workflow/store.js

@@ -0,0 +1,95 @@
+// mcp-server/src/workflow/store.ts
+import { mkdir, readFile, readdir, rename, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { resolveUnderBase } from './paths.js';
+export function summarize(state) {
+    return {
+        workflow_id: state.workflow_id,
+        title: state.title,
+        current_stage: state.current_stage,
+        status: state.status,
+        last_active: state.last_active,
+    };
+}
+async function atomicWriteFile(filePath, data) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    const tmpPath = `${filePath}.tmp`;
+    await writeFile(tmpPath, data, 'utf8');
+    await rename(tmpPath, filePath);
+}
+/**
+ * File-backed state store under {repoRoot}/.workflow:
+ *   workflows/{id}.json — one file per workflow state
+ *   index.json          — array of workflow summaries
+ * All file writes go through tmp+rename so readers never observe partial files.
+ */
+export class WorkflowStore {
+    root;
+    workflowsDir;
+    indexPath;
+    constructor(repoRoot) {
+        this.root = repoRoot;
+        this.workflowsDir = path.join(repoRoot, '.workflow', 'workflows');
+        this.indexPath = path.join(repoRoot, '.workflow', 'index.json');
+    }
+    statePath(id) {
+        return resolveUnderBase(this.workflowsDir, `${id}.json`);
+    }
+    async save(state) {
+        await atomicWriteFile(this.statePath(state.workflow_id), JSON.stringify(state, null, 2));
+        await this.updateIndex(state);
+    }
+    /** Missing workflow → null; callers turn that into an "Unknown workflow" error.
+     *  Containment is checked OUTSIDE the try so traversal ids throw, not return null. */
+    async load(id) {
+        const filePath = this.statePath(id);
+        let raw;
+        try {
+            raw = await readFile(filePath, 'utf8');
+        }
+        catch {
+            return null;
+        }
+        return JSON.parse(raw);
+    }
+    async listAll() {
+        let entries;
+        try {
+            entries = await readdir(this.workflowsDir);
+        }
+        catch {
+            return [];
+        }
+        const states = [];
+        for (const entry of entries.sort()) {
+            if (!entry.endsWith('.json'))
+                continue;
+            const raw = await readFile(path.join(this.workflowsDir, entry), 'utf8');
+            states.push(JSON.parse(raw));
+        }
+        return states;
+    }
+    /** Active = neither completed nor blocked. Derived from state files so the list self-heals. */
+    async getActiveSummaries() {
+        const states = await this.listAll();
+        return states.filter((s) => s.status !== 'completed' && s.status !== 'blocked').map(summarize);
+    }
+    async updateIndex(state) {
+        let index;
+        try {
+            index = JSON.parse(await readFile(this.indexPath, 'utf8'));
+        }
+        catch {
+            index = [];
+        }
+        const summary = summarize(state);
+        const existing = index.findIndex((e) => e.workflow_id === summary.workflow_id);
+        if (existing >= 0) {
+            index[existing] = summary;
+        }
+        else {
+            index.push(summary);
+        }
+        await atomicWriteFile(this.indexPath, JSON.stringify(index, null, 2));
+    }
+}

package/dist/workflow/template.d.ts

@@ -0,0 +1,4 @@
+/** Renders {var} placeholders; unknown placeholders stay literal. */
+export declare function renderTemplate(template: string, vars: Record<string, unknown>): string;
+/** Renders {var} placeholders; a missing variable is an error (paths must resolve). */
+export declare function renderStrict(template: string, vars: Record<string, unknown>): string;

package/dist/workflow/template.js

@@ -0,0 +1,18 @@
+// mcp-server/src/workflow/template.ts
+/** Renders {var} placeholders; unknown placeholders stay literal. */
+export function renderTemplate(template, vars) {
+    return template.replace(/\{(\w+)\}/g, (match, key) => {
+        const value = vars[key];
+        return value !== undefined ? String(value) : match;
+    });
+}
+/** Renders {var} placeholders; a missing variable is an error (paths must resolve). */
+export function renderStrict(template, vars) {
+    return template.replace(/\{(\w+)\}/g, (_, key) => {
+        const value = vars[key];
+        if (value === undefined) {
+            throw new Error(`Missing context var: ${key}`);
+        }
+        return String(value);
+    });
+}

package/dist/workflow/types.d.ts

@@ -0,0 +1,102 @@
+export type StageType = 'llm_generation' | 'gate' | 'action';
+export type GateDecision = 'approved' | 'rejected' | 'modified';
+export interface Stage {
+    id: string;
+    name: string;
+    type: StageType;
+    skill?: string;
+    prompt_template?: string;
+    inputs?: string[];
+    outputs?: string[];
+    checklist?: string[];
+    gate_prompt?: string;
+    decisions?: GateDecision[];
+    handler?: string;
+    handler_params?: Record<string, unknown>;
+    next: string;
+    on_reject?: string;
+    on_error?: string;
+    requires_approval?: boolean;
+    timeout_hours?: number;
+}
+export interface ContextVar {
+    type: 'string' | 'date' | 'slug' | 'array';
+    required: boolean;
+    source: 'user_input' | 'generated' | 'derived';
+    default?: unknown;
+}
+export interface WorkflowDefinition {
+    id: string;
+    version: string;
+    name: string;
+    stages: Stage[];
+    initial_stage: string;
+    context_schema: Record<string, ContextVar>;
+}
+export type WorkflowStatus = 'running' | 'waiting_for_user' | 'completed' | 'blocked';
+export interface StageRecord {
+    status: string;
+    output?: string[];
+    completed_at?: string;
+    approved_by?: string;
+    approved_at?: string;
+    rejected_by?: string;
+    rejected_at?: string;
+    reason?: string;
+    changes?: string;
+    result?: Record<string, unknown>;
+    error?: string;
+    retryable?: boolean;
+    failed_at?: string;
+    modified_at?: string;
+}
+export interface WorkflowState {
+    workflow_id: string;
+    intent_id: string;
+    title: string;
+    current_stage: string;
+    status: WorkflowStatus;
+    stages: Record<string, StageRecord>;
+    context: Record<string, unknown>;
+    created_at: string;
+    last_active: string;
+}
+export interface StageCompletedEvent {
+    type: 'stage.completed';
+    workflow_id: string;
+    stage_id: string;
+    output: string[];
+    timestamp: string;
+}
+export interface GateDecisionEvent {
+    type: 'gate.decision';
+    workflow_id: string;
+    stage_id: string;
+    decision: GateDecision;
+    changes?: string;
+    approved_by: string;
+    timestamp: string;
+}
+export interface ActionCompletedEvent {
+    type: 'action.completed';
+    workflow_id: string;
+    stage_id: string;
+    result: Record<string, unknown>;
+    timestamp: string;
+}
+export interface ActionFailedEvent {
+    type: 'action.failed';
+    workflow_id: string;
+    stage_id: string;
+    error: string;
+    retryable: boolean;
+    timestamp: string;
+}
+export interface WorkflowStartedEvent {
+    type: 'workflow.started';
+    workflow_id: string;
+    title: string;
+    timestamp: string;
+}
+export type WorkflowEvent = WorkflowStartedEvent | StageCompletedEvent | GateDecisionEvent | ActionCompletedEvent | ActionFailedEvent;
+export type WorkflowEventType = WorkflowEvent['type'];

package/dist/workflow/types.js

@@ -0,0 +1,3 @@
+// mcp-server/src/workflow/types.ts
+// Core type definitions for the workflow state machine.
+export {};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@aicoffe/ai-native-sdlc-mcp",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "MCP workflow state machine server for the AI-native SDLC plugin",
+  "license": "MIT",
+  "keywords": [
+    "mcp",
+    "workflow",
+    "state-machine",
+    "sdlc",
+    "ai-native"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aicoffe/ai-native-sdlc-plugin.git"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "ai-native-sdlc-mcp": "dist/main.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "start": "node dist/main.js",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.1",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.0",
+    "@types/node": "^22.0.0"
+  }
+}