@thxgg/steward 0.1.12 → 0.1.14

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.12",
+  "version": "0.1.14",
   "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/dist/app/types/graph.js

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

package/dist/host/src/api/git.js

@@ -1,5 +1,14 @@
-import { getCommitDiff, getCommitInfo, getFileContent, getFileDiff, isGitRepo, validatePathInRepo } from '../../../server/utils/git.js';
+import { commitStagedChanges, getCommitDiff, getCommitInfo, getFileContent, getFileDiff, getWorkingTreeStatus, isGitRepo, stagePaths, validatePathInRepo } from '../../../server/utils/git.js';
 import { requireRepo } from './repo-context.js';
+function toGitStatus(status) {
+    const hasStagedChanges = status.staged.length > 0;
+    const hasChanges = hasStagedChanges || status.unstaged.length > 0 || status.untracked.length > 0;
+    return {
+        ...status,
+        hasChanges,
+        hasStagedChanges
+    };
+}
 function resolveGitRepoPath(repo, repoPath) {
     if (!repoPath) {
         return repo.path;
@@ -15,6 +24,15 @@ function resolveGitRepoPath(repo, repoPath) {
     return matchedRepo.absolutePath;
 }
 export const git = {
+    async getStatus(repoId, repoPath) {
+        const repo = await requireRepo(repoId);
+        const gitRepoPath = resolveGitRepoPath(repo, repoPath);
+        if (!await isGitRepo(gitRepoPath)) {
+            throw new Error('Resolved path is not a git repository');
+        }
+        const status = await getWorkingTreeStatus(gitRepoPath);
+        return toGitStatus(status);
+    },
     async getCommits(repoId, shas, repoPath) {
         if (!Array.isArray(shas) || shas.length === 0) {
             throw new Error('At least one SHA is required');
@@ -85,5 +103,57 @@ export const git = {
             throw new Error('Resolved path is not a git repository');
         }
         return await getFileContent(gitRepoPath, commit, file);
+    },
+    async commitIfChanged(repoId, message, options) {
+        if (!message || !message.trim()) {
+            throw new Error('message is required');
+        }
+        const repo = await requireRepo(repoId);
+        const relativeRepoPath = options?.repoPath || '';
+        const gitRepoPath = resolveGitRepoPath(repo, relativeRepoPath);
+        if (!await isGitRepo(gitRepoPath)) {
+            throw new Error('Resolved path is not a git repository');
+        }
+        const paths = Array.isArray(options?.paths)
+            ? options.paths.filter((path) => typeof path === 'string' && path.trim().length > 0)
+            : [];
+        if (paths.length > 0) {
+            await stagePaths(gitRepoPath, paths);
+        }
+        const statusBefore = await getWorkingTreeStatus(gitRepoPath);
+        if (statusBefore.staged.length === 0) {
+            const noChanges = statusBefore.unstaged.length === 0 && statusBefore.untracked.length === 0;
+            return {
+                committed: false,
+                repoPath: relativeRepoPath,
+                staged: statusBefore.staged,
+                unstaged: statusBefore.unstaged,
+                untracked: statusBefore.untracked,
+                reason: noChanges ? 'no_changes' : 'no_staged_changes'
+            };
+        }
+        const commit = await commitStagedChanges(gitRepoPath, message);
+        if (!commit) {
+            return {
+                committed: false,
+                repoPath: relativeRepoPath,
+                staged: statusBefore.staged,
+                unstaged: statusBefore.unstaged,
+                untracked: statusBefore.untracked,
+                reason: 'no_staged_changes'
+            };
+        }
+        const statusAfter = await getWorkingTreeStatus(gitRepoPath);
+        return {
+            committed: true,
+            repoPath: relativeRepoPath,
+            staged: statusAfter.staged,
+            unstaged: statusAfter.unstaged,
+            untracked: statusAfter.untracked,
+            sha: commit.sha,
+            shortSha: commit.shortSha,
+            message: commit.message,
+            committedFiles: commit.files
+        };
     }
 };

package/dist/host/src/help.js

@@ -39,6 +39,10 @@ const HELP = {
             }
         ],
         git: [
+            {
+                signature: 'git.getStatus(repoId, repoPath?)',
+                description: 'Load working tree status (staged/unstaged/untracked)'
+            },
             { signature: 'git.getCommits(repoId, shas, repoPath?)', description: 'Load commit metadata' },
             { signature: 'git.getDiff(repoId, commit, repoPath?)', description: 'Load full commit diff' },
             {
@@ -48,6 +52,10 @@ const HELP = {
             {
                 signature: 'git.getFileContent(repoId, commit, file, repoPath?)',
                 description: 'Load file content at commit'
+            },
+            {
+                signature: 'git.commitIfChanged(repoId, message, options?)',
+                description: 'Stage optional paths and commit when staged changes exist'
             }
         ],
         state: [
@@ -86,6 +94,10 @@ const HELP = {
         {
             title: 'Upsert without repoId',
             code: `await state.upsertCurrent('prd-viewer', {\n  notes: '# Updated from MCP'\n})\n\nreturn { saved: true }`
+        },
+        {
+            title: 'Commit task-related changes when present',
+            code: `const repo = await repos.current()\n\nconst result = await git.commitIfChanged(repo.id, 'docs: update task notes', {\n  paths: ['docs/prd/prd-viewer.md']\n})\n\nreturn result`
         }
     ]
 };

package/dist/server/utils/git.js

@@ -55,6 +55,109 @@ export function validatePathInRepo(repoPath, filePath) {
     const relativePath = relative(resolvedRepo, resolvedFile);
     return !relativePath.startsWith('..') && !isAbsolute(relativePath);
 }
+function dedupeAndSort(values) {
+    return Array.from(new Set(values)).sort((a, b) => a.localeCompare(b));
+}
+function normalizeStatusPath(rawPath) {
+    const trimmed = rawPath.trim();
+    if (!trimmed.includes(' -> ')) {
+        return trimmed;
+    }
+    const segments = trimmed.split(' -> ');
+    return segments[segments.length - 1]?.trim() || trimmed;
+}
+function normalizePathForGit(repoPath, path) {
+    if (!validatePathInRepo(repoPath, path)) {
+        throw new Error(`Invalid file path: ${path}`);
+    }
+    const absolutePath = isAbsolute(path)
+        ? resolve(path)
+        : resolve(repoPath, path);
+    const relativePath = relative(resolve(repoPath), absolutePath);
+    if (!relativePath || relativePath === '.') {
+        throw new Error('Path must point to a file or subdirectory inside the repository');
+    }
+    return relativePath;
+}
+/**
+ * Get working tree changes split by staged/unstaged/untracked buckets.
+ */
+export async function getWorkingTreeStatus(repoPath) {
+    const output = await execGit(repoPath, ['status', '--porcelain']);
+    const staged = new Set();
+    const unstaged = new Set();
+    const untracked = new Set();
+    const lines = output
+        .split('\n')
+        .map(line => line.trimEnd())
+        .filter(line => line.length >= 3);
+    for (const line of lines) {
+        const indexStatus = line.charAt(0);
+        const worktreeStatus = line.charAt(1);
+        const path = normalizeStatusPath(line.slice(3));
+        if (!path) {
+            continue;
+        }
+        if (indexStatus === '?' && worktreeStatus === '?') {
+            untracked.add(path);
+            continue;
+        }
+        if (indexStatus !== ' ' && indexStatus !== '?') {
+            staged.add(path);
+        }
+        if (worktreeStatus !== ' ') {
+            unstaged.add(path);
+        }
+    }
+    return {
+        staged: dedupeAndSort(staged),
+        unstaged: dedupeAndSort(unstaged),
+        untracked: dedupeAndSort(untracked)
+    };
+}
+/**
+ * Stage explicit paths in a repository.
+ */
+export async function stagePaths(repoPath, paths) {
+    if (!Array.isArray(paths) || paths.length === 0) {
+        return [];
+    }
+    const normalizedPaths = dedupeAndSort(paths
+        .map(path => path.trim())
+        .filter(path => path.length > 0)
+        .map(path => normalizePathForGit(repoPath, path)));
+    if (normalizedPaths.length === 0) {
+        return [];
+    }
+    await execGit(repoPath, ['add', '--', ...normalizedPaths]);
+    return normalizedPaths;
+}
+/**
+ * Commit currently staged changes. Returns null when nothing is staged.
+ */
+export async function commitStagedChanges(repoPath, message) {
+    const trimmedMessage = message.trim();
+    if (!trimmedMessage) {
+        throw new Error('Commit message is required');
+    }
+    const stagedOutput = await execGit(repoPath, ['diff', '--cached', '--name-only']);
+    const stagedFiles = stagedOutput
+        .split('\n')
+        .map(line => line.trim())
+        .filter(line => line.length > 0);
+    if (stagedFiles.length === 0) {
+        return null;
+    }
+    await execGit(repoPath, ['commit', '-m', trimmedMessage]);
+    const sha = (await execGit(repoPath, ['rev-parse', 'HEAD'])).trim();
+    const shortSha = (await execGit(repoPath, ['rev-parse', '--short', 'HEAD'])).trim();
+    return {
+        sha,
+        shortSha,
+        message: trimmedMessage,
+        files: stagedFiles
+    };
+}
 /**
  * Get commit information by SHA
  */
@@ -333,7 +436,7 @@ async function commitExistsInRepo(repoPath, sha) {
  *
  * @param repoConfig - The repository configuration with optional gitRepos
  * @param sha - The commit SHA to find
- * @returns The GitRepoInfo where the commit was found, or throws if not found
+ * @returns Resolved commit data for the matching repo, or throws if not found
  */
 export async function findRepoForCommit(repoConfig, sha) {
     // Validate SHA format

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

@@ -119,10 +119,12 @@ In-sandbox discovery helper:
 
 ### `git`
 
+- `git.getStatus(repoId, repoPath?)`
 - `git.getCommits(repoId, shas, repoPath?)`
 - `git.getDiff(repoId, commit, repoPath?)`
 - `git.getFileDiff(repoId, commit, file, repoPath?)`
 - `git.getFileContent(repoId, commit, file, repoPath?)`
+- `git.commitIfChanged(repoId, message, options?)`
 
 ### `state`
 
@@ -181,6 +183,24 @@ return await Promise.all(commits.map(async (entry) => ({
 })))
 ```
 
+Commit task-related changes when present:
+
+```js
+const repo = await repos.current()
+
+const commit = await git.commitIfChanged(repo.id, 'test: add task graph coverage', {
+  paths: ['app/components/graph/Explorer.spec.ts']
+})
+
+return commit
+```
+
+`git.commitIfChanged` behavior:
+
+- stages only the explicit `options.paths` list when provided
+- commits only when staged changes exist
+- returns `committed: false` with `reason: "no_changes" | "no_staged_changes"` instead of creating empty commits
+
 Inspect signatures at runtime:
 
 ```js
@@ -238,4 +258,5 @@ return { saved: true }
 
 - This server is for trusted local development.
 - APIs can read local filesystem and git history for registered repositories.
+- `git.commitIfChanged` can create local commits when staged changes exist.
 - Do not expose this server to untrusted environments.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thxgg/steward",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "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",