@thxgg/steward 0.1.13 → 0.1.15

package/.output/server/node_modules/@vue-flow/core/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@vue-flow/core",
+  "version": "1.48.2",
+  "private": false,
+  "license": "MIT",
+  "author": "Burak Cakmakoglu<78412429+bcakmakoglu@users.noreply.github.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bcakmakoglu/vue-flow",
+    "directory": "packages/core"
+  },
+  "homepage": "https://vueflow.dev",
+  "bugs": {
+    "url": "https://github.com/bcakmakoglu/vue-flow/issues"
+  },
+  "keywords": [
+    "vue",
+    "flow",
+    "diagram",
+    "editor",
+    "graph",
+    "node",
+    "link",
+    "port",
+    "slot",
+    "vue3",
+    "composition-api",
+    "vue-flow",
+    "vueflow",
+    "typescript"
+  ],
+  "main": "./dist/vue-flow-core.js",
+  "module": "./dist/vue-flow-core.mjs",
+  "types": "./dist/index.d.ts",
+  "unpkg": "./dist/vue-flow-core.iife.js",
+  "jsdelivr": "./dist/vue-flow-core.iife.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/vue-flow-core.mjs",
+      "require": "./dist/vue-flow-core.js"
+    },
+    "./dist/style.css": "./dist/style.css",
+    "./dist/theme-default.css": "./dist/theme-default.css"
+  },
+  "files": [
+    "dist",
+    "*.d.ts"
+  ],
+  "sideEffects": [
+    "*.css"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "peerDependencies": {
+    "vue": "^3.3.0"
+  },
+  "dependencies": {
+    "@vueuse/core": "^10.5.0",
+    "d3-drag": "^3.0.0",
+    "d3-interpolate": "^3.0.1",
+    "d3-selection": "^3.0.0",
+    "d3-zoom": "^3.0.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-replace": "^5.0.3",
+    "@types/d3-drag": "^3.0.7",
+    "@types/d3-interpolate": "^3.0.4",
+    "@types/d3-selection": "^3.0.11",
+    "@types/d3-transition": "^3.0.9",
+    "@types/d3-zoom": "^3.0.8",
+    "@vitejs/plugin-vue": "^4.4.0",
+    "autoprefixer": "^10.4.16",
+    "postcss": "^8.4.31",
+    "postcss-cli": "^10.1.0",
+    "postcss-nested": "^6.0.1",
+    "vite": "^4.4.11",
+    "vue-tsc": "^1.8.16",
+    "@tooling/eslint-config": "0.0.0",
+    "@tooling/tsconfig": "0.0.0"
+  },
+  "scripts": {
+    "dev": "pnpm types:watch & pnpm build:watch",
+    "build": "vite build && vite build -c vite.config.iife.ts",
+    "build:watch": "vite build --watch & vite build -c vite.config.iife.ts --watch",
+    "types": "vue-tsc --declaration --emitDeclarationOnly && tsc -p ./tsconfig.build.json && shx rm -rf tmp && pnpm lint:dist",
+    "types:watch": "vue-tsc --declaration --emitDeclarationOnly --watch & tsc -p ./tsconfig.build.json --watch",
+    "theme": "postcss src/style.css -o dist/style.css && postcss src/theme-default.css -o dist/theme-default.css",
+    "lint": "eslint --ext .js,.ts,.vue ./",
+    "lint:dist": "eslint --ext \".ts,.tsx\" -c .eslintrc.js --fix --ignore-pattern !**/*  ./dist",
+    "test": "exit 0"
+  }
+}

package/.output/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thxgg/steward-prod",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "type": "module",
   "private": true,
   "dependencies": {
@@ -21,6 +21,9 @@
     "@swc/helpers": "0.5.18",
     "@tanstack/virtual-core": "3.13.18",
     "@tanstack/vue-virtual": "3.13.18",
+    "@vue-flow/background": "1.3.2",
+    "@vue-flow/controls": "1.1.3",
+    "@vue-flow/core": "1.48.2",
     "@vue/compiler-core": "3.5.28",
     "@vue/compiler-dom": "3.5.28",
     "@vue/compiler-ssr": "3.5.28",

package/README.md

@@ -69,9 +69,10 @@ prd mcp
                     │
                     ▼
 ┌─────────────────────────────────────────┐
-│         Codemode MCP (`execute`)        │
+│   Codemode MCP (`execute` + prompts)    │
 │  - VM sandbox                           │
 │  - APIs: repos, prds, git, state        │
+│  - Prompts: create/break/complete flow  │
 └─────────────────────────────────────────┘
                     │
                     ▼
@@ -85,6 +86,14 @@ prd mcp
 
 Steward exposes one MCP tool: `execute`.
 
+It also exposes workflow prompts:
+
+- `create_prd(feature_request)`
+- `break_into_tasks(prd_slug)`
+- `complete_next_task(prd_slug)`
+
+In OpenCode these are shown as MCP slash entries like `/prd:create_prd:mcp`.
+
 ```js
 const repo = await repos.current()
 

package/dist/app/types/graph.js

@@ -0,0 +1 @@
+export {};

package/dist/host/src/mcp.js

@@ -4,6 +4,7 @@ import { z } from 'zod';
 import { assertSqliteRuntimeSupport } from '../../server/utils/db.js';
 import { execute } from './executor.js';
 import { getExecuteToolDescription } from './help.js';
+import { registerStewardPrompts } from './prompts.js';
 function serializeEnvelope(envelope) {
     try {
         return JSON.stringify(envelope, null, 2);
@@ -55,6 +56,7 @@ export async function runMcpServer() {
         name: 'steward',
         version: '0.1.0'
     });
+    registerStewardPrompts(server);
     server.tool('execute', getExecuteToolDescription(), {
         code: z.string().optional()
     }, async ({ code }) => {

package/dist/host/src/prompts.js

@@ -0,0 +1,127 @@
+import { z } from 'zod';
+function textMessage(text) {
+    return {
+        role: 'user',
+        content: {
+            type: 'text',
+            text
+        }
+    };
+}
+function createPrdPrompt(featureRequest) {
+    return [
+        'You are using Steward MCP to create a new Product Requirements Document (PRD).',
+        '',
+        'User request:',
+        featureRequest,
+        '',
+        'Workflow:',
+        '1. Clarify any major ambiguities with targeted questions before writing the PRD.',
+        '2. Derive a kebab-case slug and create docs/prd/<slug>.md.',
+        '3. Use this PRD structure at minimum:',
+        '   - # PRD: <Feature Name>',
+        '   - **Author:** Generated',
+        '   - **Date:** <YYYY-MM-DD>',
+        '   - **Status:** Draft',
+        '   - Problem Statement, Users, Proposed Solution, Scope, Technical Considerations, Success Criteria, Risks.',
+        '4. Before finishing, verify Steward repository registration with the execute tool:',
+        '   const existing = await repos.list()',
+        '   return existing.map((repo) => ({ id: repo.id, name: repo.name, path: repo.path }))',
+        '   If no repository is registered, register this repository with repos.add(<absolute_path>, <optional_name>).',
+        '5. Do not generate tasks in this step.',
+        '6. End with:',
+        '   - created PRD path',
+        '   - chosen slug',
+        '   - key product decisions and open questions',
+        '   - recommended next command: /prd:break_into_tasks <slug> (shown as :mcp in autocomplete).'
+    ].join('\n');
+}
+function breakIntoTasksPrompt(prdSlug) {
+    return [
+        'You are converting a PRD into structured Steward task state.',
+        '',
+        'PRD slug:',
+        prdSlug,
+        '',
+        'Workflow:',
+        '1. Load docs/prd/<slug>.md. If not found, list available PRDs and stop with a clear correction.',
+        '2. Update PRD status from Draft to Approved in the markdown file.',
+        '3. Build tasks JSON with this shape:',
+        '   { prd: { name, source, createdAt }, tasks: [{ id, category, title, description, steps, passes, dependencies, priority, status }] }',
+        '4. Use these category values only: setup, feature, integration, testing, documentation.',
+        '5. Use these priority values only: critical, high, medium, low.',
+        '6. Set every generated task status to pending and make passes an array of testable criteria.',
+        '7. Build progress JSON with this shape:',
+        '   { prdName, totalTasks, completed, inProgress, blocked, startedAt, lastUpdated, patterns, taskLogs }',
+        '   Initialize with completed=0, inProgress=0, blocked=0, startedAt=null, patterns=[], taskLogs=[].',
+        '8. Persist state through execute tool:',
+        `   await state.upsertCurrent("${prdSlug}", { tasks: <tasksJson>, progress: <progressJson> })`,
+        `   return await state.getCurrent("${prdSlug}")`,
+        '9. Report task count, category breakdown, critical path, and recommended next command:',
+        `   /prd:complete_next_task ${prdSlug} (shown as :mcp in autocomplete).`
+    ].join('\n');
+}
+function completeNextTaskPrompt(prdSlug) {
+    return [
+        'You are completing the next PRD task with Steward state tracking and commits.',
+        '',
+        'PRD slug:',
+        prdSlug,
+        '',
+        'Workflow:',
+        `1. Load PRD state using execute tool: state.getCurrent("${prdSlug}").`,
+        `   If tasks are missing, stop and instruct to run /prd:break_into_tasks ${prdSlug}.`,
+        '2. Select the next task:',
+        '   - first task with status=in_progress, otherwise',
+        '   - first pending task whose dependencies are all completed.',
+        '3. Immediately mark the task in progress and save with state.upsertCurrent:',
+        '   - task.status = in_progress',
+        '   - task.startedAt = ISO timestamp (if absent)',
+        '   - progress.inProgress updated',
+        '   - progress.lastUpdated updated',
+        '   - taskLogs entry exists with { taskId, status: in_progress, startedAt }',
+        '4. Implement only this task in repository files.',
+        '5. Run validation loops relevant to the project before commit (typecheck, tests, lint, format/build where applicable).',
+        '6. Commit task-related changes with a concise conventional commit message.',
+        '7. Capture commit SHAs and update taskLogs[].commits (use { sha, repo } objects for nested repos when needed).',
+        '8. Mark task completed and save with state.upsertCurrent:',
+        '   - task.status = completed',
+        '   - task.completedAt = ISO timestamp',
+        '   - progress.completed / progress.inProgress / progress.lastUpdated updated',
+        '   - taskLogs entry updated with completedAt, implemented, filesChanged, learnings, commits',
+        '9. If all tasks are completed, output exactly: <tasks>COMPLETE</tasks>.',
+        '10. Report what changed, which commit(s) were created, and the next pending task if any.'
+    ].join('\n');
+}
+export function registerStewardPrompts(server) {
+    server.registerPrompt('create_prd', {
+        title: 'Create PRD',
+        description: 'Create a PRD markdown document and prepare Steward workflow context.',
+        argsSchema: {
+            feature_request: z.string().describe('Feature request, idea, or problem statement for the PRD')
+        }
+    }, async ({ feature_request }) => ({
+        description: 'Guided workflow for creating a PRD file.',
+        messages: [textMessage(createPrdPrompt(feature_request))]
+    }));
+    server.registerPrompt('break_into_tasks', {
+        title: 'Break Into Tasks',
+        description: 'Convert a PRD into tasks.json/progress.json style state and save it.',
+        argsSchema: {
+            prd_slug: z.string().describe('PRD slug, usually the filename in docs/prd without .md')
+        }
+    }, async ({ prd_slug }) => ({
+        description: 'Workflow for converting an approved PRD into task state.',
+        messages: [textMessage(breakIntoTasksPrompt(prd_slug))]
+    }));
+    server.registerPrompt('complete_next_task', {
+        title: 'Complete Next Task',
+        description: 'Complete the next in-progress/pending task and persist state updates.',
+        argsSchema: {
+            prd_slug: z.string().describe('PRD slug whose next task should be completed')
+        }
+    }, async ({ prd_slug }) => ({
+        description: 'Workflow for task execution, verification, commit capture, and state persistence.',
+        messages: [textMessage(completeNextTaskPrompt(prd_slug))]
+    }));
+}

package/dist/server/utils/task-graph.js

@@ -0,0 +1,190 @@
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+import { getPrdState, getPrdStateSummaries, migrateLegacyStateForRepo } from './prd-state.js';
+const NODE_SEPARATOR = '::';
+const MISSING_PREFIX = 'missing';
+export function createTaskNodeId(prdSlug, taskId) {
+    return `${prdSlug}${NODE_SEPARATOR}${taskId}`;
+}
+function createMissingNodeId(prdSlug, taskId) {
+    return `${MISSING_PREFIX}${NODE_SEPARATOR}${prdSlug}${NODE_SEPARATOR}${taskId}`;
+}
+function createEdgeId(source, target) {
+    return `${source}->${target}`;
+}
+function parseDependency(rawDependency, currentPrdSlug) {
+    const trimmed = rawDependency.trim();
+    if (!trimmed) {
+        return {
+            prdSlug: currentPrdSlug,
+            taskId: rawDependency,
+            reference: rawDependency
+        };
+    }
+    const parts = trimmed.split(NODE_SEPARATOR);
+    if (parts.length === 2) {
+        const [prdSlug, taskId] = parts;
+        if (prdSlug && taskId) {
+            return {
+                prdSlug,
+                taskId,
+                reference: `${prdSlug}${NODE_SEPARATOR}${taskId}`
+            };
+        }
+    }
+    return {
+        prdSlug: currentPrdSlug,
+        taskId: trimmed,
+        reference: trimmed
+    };
+}
+async function resolvePrdName(repo, prdSlug) {
+    const prdPath = join(repo.path, 'docs', 'prd', `${prdSlug}.md`);
+    try {
+        const content = await fs.readFile(prdPath, 'utf-8');
+        const h1Match = content.match(/^#\s+(.+)$/m);
+        return h1Match?.[1]?.trim() || prdSlug;
+    }
+    catch {
+        return prdSlug;
+    }
+}
+function buildStats(taskNodes, unresolvedCount) {
+    const pending = taskNodes.filter((node) => node.status === 'pending').length;
+    const inProgress = taskNodes.filter((node) => node.status === 'in_progress').length;
+    const completed = taskNodes.filter((node) => node.status === 'completed').length;
+    return {
+        total: taskNodes.length,
+        pending,
+        inProgress,
+        completed,
+        unresolved: unresolvedCount
+    };
+}
+function sortNodes(nodes) {
+    return [...nodes].sort((a, b) => {
+        if (a.kind !== b.kind) {
+            return a.kind === 'task' ? -1 : 1;
+        }
+        return a.id.localeCompare(b.id);
+    });
+}
+function sortEdges(edges) {
+    return [...edges].sort((a, b) => a.id.localeCompare(b.id));
+}
+function buildGraphFromInputs(inputs) {
+    const taskNodes = new Map();
+    const missingNodes = new Map();
+    const edges = new Map();
+    for (const input of inputs) {
+        for (const task of input.tasks) {
+            const nodeId = createTaskNodeId(input.prdSlug, task.id);
+            taskNodes.set(nodeId, {
+                id: nodeId,
+                kind: 'task',
+                taskId: task.id,
+                prdSlug: input.prdSlug,
+                prdName: input.prdName,
+                title: task.title,
+                status: task.status,
+                category: task.category,
+                priority: task.priority
+            });
+        }
+    }
+    for (const input of inputs) {
+        for (const task of input.tasks) {
+            const targetId = createTaskNodeId(input.prdSlug, task.id);
+            for (const rawDependency of task.dependencies) {
+                const dependency = parseDependency(rawDependency, input.prdSlug);
+                const sourceTaskId = createTaskNodeId(dependency.prdSlug, dependency.taskId);
+                if (taskNodes.has(sourceTaskId)) {
+                    const edgeId = createEdgeId(sourceTaskId, targetId);
+                    edges.set(edgeId, {
+                        id: edgeId,
+                        source: sourceTaskId,
+                        target: targetId,
+                        type: 'dependency'
+                    });
+                    continue;
+                }
+                const missingNodeId = createMissingNodeId(dependency.prdSlug, dependency.taskId);
+                if (!missingNodes.has(missingNodeId)) {
+                    missingNodes.set(missingNodeId, {
+                        id: missingNodeId,
+                        kind: 'external',
+                        title: `Missing: ${dependency.reference}`,
+                        unresolved: true,
+                        dependencyRef: dependency.reference
+                    });
+                }
+                const unresolvedEdgeId = createEdgeId(missingNodeId, targetId);
+                edges.set(unresolvedEdgeId, {
+                    id: unresolvedEdgeId,
+                    source: missingNodeId,
+                    target: targetId,
+                    type: 'dependency',
+                    unresolved: true
+                });
+            }
+        }
+    }
+    const taskNodeList = [...taskNodes.values()];
+    const nodeList = sortNodes([...taskNodeList, ...missingNodes.values()]);
+    const edgeList = sortEdges([...edges.values()]);
+    return {
+        nodes: nodeList,
+        edges: edgeList,
+        stats: buildStats(taskNodeList, missingNodes.size)
+    };
+}
+export async function buildPrdGraph(repo, prdSlug) {
+    await migrateLegacyStateForRepo(repo);
+    const [state, prdName] = await Promise.all([
+        getPrdState(repo.id, prdSlug),
+        resolvePrdName(repo, prdSlug)
+    ]);
+    const tasks = Array.isArray(state?.tasks?.tasks) ? state.tasks.tasks : [];
+    const graph = buildGraphFromInputs([
+        {
+            prdSlug,
+            prdName,
+            tasks
+        }
+    ]);
+    return {
+        scope: 'prd',
+        repoId: repo.id,
+        prdSlug,
+        nodes: graph.nodes,
+        edges: graph.edges,
+        stats: graph.stats
+    };
+}
+export async function buildRepoGraph(repo) {
+    await migrateLegacyStateForRepo(repo);
+    const summaries = await getPrdStateSummaries(repo.id);
+    const slugs = [...summaries.keys()].sort((a, b) => a.localeCompare(b));
+    const inputs = [];
+    for (const slug of slugs) {
+        const state = await getPrdState(repo.id, slug);
+        const tasks = state?.tasks?.tasks;
+        if (!Array.isArray(tasks)) {
+            continue;
+        }
+        inputs.push({
+            prdSlug: slug,
+            prdName: await resolvePrdName(repo, slug),
+            tasks
+        });
+    }
+    const graph = buildGraphFromInputs(inputs);
+    return {
+        scope: 'repo',
+        repoId: repo.id,
+        prds: inputs.map((input) => input.prdSlug).sort((a, b) => a.localeCompare(b)),
+        nodes: graph.nodes,
+        edges: graph.edges,
+        stats: graph.stats
+    };
+}

package/docs/MCP.md

@@ -4,7 +4,9 @@ Steward ships a codemode MCP server.
 
 - Command: `prd mcp`
 - Transport: stdio
-- Tool surface: one tool, `execute`
+- MCP surface:
+  - Tool: `execute`
+  - Prompts: `create_prd`, `break_into_tasks`, `complete_next_task`
 
 The `execute` tool runs JavaScript in a VM sandbox with these APIs in scope:
 
@@ -98,6 +100,16 @@ In-sandbox discovery helper:
 
 - `steward.help()`
 
+## MCP Prompts
+
+Steward also exposes MCP prompts so MCP clients can surface command-like workflows.
+
+- `create_prd(feature_request)`
+- `break_into_tasks(prd_slug)`
+- `complete_next_task(prd_slug)`
+
+In OpenCode, these appear in slash-command autocomplete as MCP commands (for example `/prd:create_prd:mcp`) and insert as `/prd:create_prd` when selected.
+
 ## Available APIs
 
 ### `repos`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thxgg/steward",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "Local-first PRD workflow steward with codemode MCP and web UI.",
   "type": "module",
   "author": "thxgg",
@@ -54,7 +54,11 @@
     "prepack": "npm run build"
   },
   "dependencies": {
+    "@dagrejs/dagre": "^2.0.4",
     "@modelcontextprotocol/sdk": "^1.26.0",
+    "@vue-flow/background": "^1.3.2",
+    "@vue-flow/controls": "^1.1.3",
+    "@vue-flow/core": "^1.48.2",
     "@vueuse/core": "^14.1.0",
     "chokidar": "^5.0.0",
     "class-variance-authority": "^0.7.1",