@thxgg/steward 0.1.12 → 0.1.13

package/.output/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thxgg/steward-prod",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "type": "module",
   "private": true,
   "dependencies": {

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/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.13",
   "description": "Local-first PRD workflow steward with codemode MCP and web UI.",
   "type": "module",
   "author": "thxgg",

package/.output/public/_nuxt/builds/meta/6f66fabf-cc26-482b-8adf-f8731dd68f83.json

@@ -1 +0,0 @@
-{"id":"6f66fabf-cc26-482b-8adf-f8731dd68f83","timestamp":1771871608410,"prerendered":[]}