@thxgg/steward 0.1.0

package/dist/host/src/ui.js

@@ -0,0 +1,64 @@
+import { existsSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const require = createRequire(import.meta.url);
+function findPackageRoot(startDir) {
+    let currentDir = startDir;
+    while (true) {
+        if (existsSync(join(currentDir, 'package.json'))) {
+            return currentDir;
+        }
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir) {
+            throw new Error('Unable to locate package root from current runtime path');
+        }
+        currentDir = parentDir;
+    }
+}
+const packageRoot = findPackageRoot(dirname(fileURLToPath(import.meta.url)));
+function resolveNuxtEntrypoint() {
+    const packageJsonPath = require.resolve('nuxt/package.json', { paths: [packageRoot] });
+    return join(dirname(packageJsonPath), 'bin', 'nuxt.mjs');
+}
+export async function runUi(options) {
+    const script = options.preview ? 'preview' : 'dev';
+    const args = [resolveNuxtEntrypoint(), script];
+    if (options.port !== undefined || options.host) {
+        if (options.port !== undefined) {
+            args.push('--port', String(options.port));
+        }
+        if (options.host) {
+            args.push('--host', options.host);
+        }
+    }
+    const child = spawn(process.execPath, args, {
+        cwd: packageRoot,
+        stdio: 'inherit',
+        env: process.env
+    });
+    return await new Promise((resolveExit, reject) => {
+        const forwardSignal = (signal) => {
+            if (!child.killed) {
+                child.kill(signal);
+            }
+        };
+        process.on('SIGINT', forwardSignal);
+        process.on('SIGTERM', forwardSignal);
+        child.on('error', (error) => {
+            process.off('SIGINT', forwardSignal);
+            process.off('SIGTERM', forwardSignal);
+            reject(error);
+        });
+        child.on('exit', (code, signal) => {
+            process.off('SIGINT', forwardSignal);
+            process.off('SIGTERM', forwardSignal);
+            if (signal) {
+                process.kill(process.pid, signal);
+                return;
+            }
+            resolveExit(code ?? 0);
+        });
+    });
+}

package/dist/server/utils/db.js

@@ -0,0 +1,125 @@
+import { promises as fs } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+const DEFAULT_DATA_HOME = process.env.XDG_DATA_HOME || join(homedir(), '.local', 'share');
+const DEFAULT_DB_PATH = join(DEFAULT_DATA_HOME, 'prd', 'state.db');
+let adapterPromise = null;
+function coerceChanges(result) {
+    if (!result || typeof result !== 'object') {
+        return 0;
+    }
+    const maybeChanges = result.changes;
+    return typeof maybeChanges === 'number' ? maybeChanges : 0;
+}
+function resolveDbPath() {
+    const customPath = process.env.PRD_STATE_DB_PATH;
+    if (customPath && customPath.trim().length > 0) {
+        return customPath;
+    }
+    const customHome = process.env.PRD_STATE_HOME;
+    if (customHome && customHome.trim().length > 0) {
+        return join(customHome, 'state.db');
+    }
+    return DEFAULT_DB_PATH;
+}
+export function getDbPath() {
+    return resolveDbPath();
+}
+async function createNodeAdapter(dbPath) {
+    const sqliteModule = await import('node:sqlite');
+    const db = new sqliteModule.DatabaseSync(dbPath);
+    return {
+        exec(sql) {
+            db.exec(sql);
+        },
+        run(sql, params = []) {
+            const result = db.prepare(sql).run(...params);
+            return { changes: coerceChanges(result) };
+        },
+        get(sql, params = []) {
+            const row = db.prepare(sql).get(...params);
+            return row ? row : null;
+        },
+        all(sql, params = []) {
+            return db.prepare(sql).all(...params);
+        }
+    };
+}
+async function createBunAdapter(dbPath) {
+    const bunModuleName = 'bun:sqlite';
+    const sqliteModule = await import(bunModuleName);
+    const Database = sqliteModule.Database;
+    const db = new Database(dbPath, { create: true });
+    return {
+        exec(sql) {
+            db.exec(sql);
+        },
+        run(sql, params = []) {
+            const result = db.query(sql).run(...params);
+            return { changes: coerceChanges(result) };
+        },
+        get(sql, params = []) {
+            const row = db.query(sql).get(...params);
+            return row ?? null;
+        },
+        all(sql, params = []) {
+            return db.query(sql).all(...params);
+        }
+    };
+}
+async function initializeDatabase() {
+    const dbPath = resolveDbPath();
+    await fs.mkdir(dirname(dbPath), { recursive: true });
+    const isBunRuntime = typeof globalThis.Bun !== 'undefined';
+    const adapter = isBunRuntime
+        ? await createBunAdapter(dbPath)
+        : await createNodeAdapter(dbPath);
+    adapter.exec('PRAGMA journal_mode = WAL;');
+    adapter.exec('PRAGMA foreign_keys = ON;');
+    adapter.exec('PRAGMA busy_timeout = 5000;');
+    adapter.exec(`
+    CREATE TABLE IF NOT EXISTS repos (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      path TEXT NOT NULL UNIQUE,
+      added_at TEXT NOT NULL,
+      git_repos_json TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS prd_states (
+      repo_id TEXT NOT NULL,
+      slug TEXT NOT NULL,
+      tasks_json TEXT,
+      progress_json TEXT,
+      notes_md TEXT,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (repo_id, slug),
+      FOREIGN KEY (repo_id) REFERENCES repos(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_prd_states_repo_id ON prd_states(repo_id);
+  `);
+    return adapter;
+}
+async function getAdapter() {
+    if (!adapterPromise) {
+        adapterPromise = initializeDatabase();
+    }
+    return adapterPromise;
+}
+export async function dbRun(sql, params = []) {
+    const adapter = await getAdapter();
+    return adapter.run(sql, params);
+}
+export async function dbGet(sql, params = []) {
+    const adapter = await getAdapter();
+    return adapter.get(sql, params);
+}
+export async function dbAll(sql, params = []) {
+    const adapter = await getAdapter();
+    return adapter.all(sql, params);
+}
+export async function dbExec(sql) {
+    const adapter = await getAdapter();
+    adapter.exec(sql);
+}

package/dist/server/utils/git.js

@@ -0,0 +1,396 @@
+import { spawn } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+import { join, resolve, relative, isAbsolute } from 'node:path';
+/**
+ * Execute a git command and return stdout
+ */
+async function execGit(repoPath, args) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn('git', args, {
+            cwd: repoPath,
+            env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+        });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        proc.on('close', (code) => {
+            if (code === 0) {
+                resolve(stdout);
+            }
+            else {
+                reject(new Error(stderr || `git exited with code ${code}`));
+            }
+        });
+        proc.on('error', (err) => {
+            reject(new Error(`Failed to spawn git: ${err.message}`));
+        });
+    });
+}
+/**
+ * Check if a path is a valid git repository
+ */
+export async function isGitRepo(path) {
+    try {
+        await execGit(path, ['rev-parse', '--git-dir']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validate that a file path is within the repository
+ */
+export function validatePathInRepo(repoPath, filePath) {
+    const resolvedRepo = resolve(repoPath);
+    const resolvedFile = isAbsolute(filePath)
+        ? resolve(filePath)
+        : resolve(repoPath, filePath);
+    // Check that the file is within the repo
+    const relativePath = relative(resolvedRepo, resolvedFile);
+    return !relativePath.startsWith('..') && !isAbsolute(relativePath);
+}
+/**
+ * Get commit information by SHA
+ */
+export async function getCommitInfo(repoPath, sha) {
+    // Validate SHA format (hex string, 4-40 chars)
+    if (!/^[0-9a-f]{4,40}$/i.test(sha)) {
+        throw new Error(`Invalid commit SHA: ${sha}`);
+    }
+    // Get commit details
+    const format = '%H%n%h%n%s%n%an%n%aI';
+    const output = await execGit(repoPath, ['show', sha, '--format=' + format, '--no-patch']);
+    const lines = output.trim().split('\n');
+    if (lines.length < 5) {
+        throw new Error(`Failed to parse commit info for ${sha}`);
+    }
+    // Get stats
+    const statsOutput = await execGit(repoPath, ['show', sha, '--format=', '--numstat']);
+    const statsLines = statsOutput.trim().split('\n').filter(l => l.trim());
+    let additions = 0;
+    let deletions = 0;
+    let filesChanged = 0;
+    for (const line of statsLines) {
+        const parts = line.split('\t');
+        const added = parts[0];
+        const deleted = parts[1];
+        if (added && deleted && added !== '-' && deleted !== '-') {
+            additions += parseInt(added, 10) || 0;
+            deletions += parseInt(deleted, 10) || 0;
+        }
+        filesChanged++;
+    }
+    return {
+        sha: lines[0],
+        shortSha: lines[1],
+        message: lines[2],
+        author: lines[3],
+        date: lines[4],
+        filesChanged,
+        additions,
+        deletions,
+    };
+}
+/**
+ * Get list of changed files in a commit with stats
+ */
+export async function getCommitDiff(repoPath, sha) {
+    // Validate SHA format
+    if (!/^[0-9a-f]{4,40}$/i.test(sha)) {
+        throw new Error(`Invalid commit SHA: ${sha}`);
+    }
+    // Get file status and stats
+    const output = await execGit(repoPath, [
+        'show', sha,
+        '--format=',
+        '--name-status',
+        '--numstat',
+    ]);
+    // Parse the output - first part is numstat, then name-status
+    const lines = output.trim().split('\n').filter(l => l.trim());
+    // We need to get both numstat and name-status info
+    const numstatOutput = await execGit(repoPath, ['show', sha, '--format=', '--numstat']);
+    const nameStatusOutput = await execGit(repoPath, ['show', sha, '--format=', '--name-status']);
+    const numstatLines = numstatOutput.trim().split('\n').filter(l => l.trim());
+    const nameStatusLines = nameStatusOutput.trim().split('\n').filter(l => l.trim());
+    const files = [];
+    const statsMap = new Map();
+    // Parse numstat (additions, deletions, path)
+    // Binary files show as "-\t-\tfilepath"
+    for (const line of numstatLines) {
+        const parts = line.split('\t');
+        if (parts.length >= 3) {
+            const added = parts[0];
+            const deleted = parts[1];
+            const pathParts = parts.slice(2);
+            const path = pathParts.join('\t'); // Handle paths with tabs (rare but possible)
+            const isBinary = added === '-' && deleted === '-';
+            statsMap.set(path, {
+                additions: isBinary ? 0 : parseInt(added, 10) || 0,
+                deletions: isBinary ? 0 : parseInt(deleted, 10) || 0,
+                binary: isBinary,
+            });
+        }
+    }
+    // Parse name-status (status, path, [oldPath for renames])
+    for (const line of nameStatusLines) {
+        const parts = line.split('\t');
+        if (parts.length < 2 || !parts[0] || !parts[1])
+            continue;
+        const statusChar = parts[0].charAt(0);
+        let status;
+        let path;
+        let oldPath;
+        switch (statusChar) {
+            case 'A':
+                status = 'added';
+                path = parts[1];
+                break;
+            case 'D':
+                status = 'deleted';
+                path = parts[1];
+                break;
+            case 'M':
+                status = 'modified';
+                path = parts[1];
+                break;
+            case 'R':
+                status = 'renamed';
+                oldPath = parts[1];
+                path = parts[2] || parts[1];
+                break;
+            case 'C':
+                status = 'added'; // Treat copy as added
+                path = parts[2] || parts[1];
+                break;
+            default:
+                status = 'modified';
+                path = parts[1];
+        }
+        // Get stats for this file
+        const stats = statsMap.get(path) ||
+            (oldPath ? statsMap.get(`${oldPath} => ${path}`) : undefined) ||
+            statsMap.get(`${oldPath}\t${path}`) ||
+            { additions: 0, deletions: 0, binary: false };
+        files.push({
+            path,
+            status,
+            oldPath,
+            additions: stats.additions,
+            deletions: stats.deletions,
+            binary: stats.binary,
+        });
+    }
+    return files;
+}
+/**
+ * Get diff hunks for a specific file in a commit
+ */
+export async function getFileDiff(repoPath, sha, filePath) {
+    // Validate SHA format
+    if (!/^[0-9a-f]{4,40}$/i.test(sha)) {
+        throw new Error(`Invalid commit SHA: ${sha}`);
+    }
+    // Validate path is within repo
+    if (!validatePathInRepo(repoPath, filePath)) {
+        throw new Error('File path is outside repository');
+    }
+    // Get diff for specific file
+    const output = await execGit(repoPath, [
+        'show', sha,
+        '--format=',
+        '--unified=3',
+        '--', filePath,
+    ]);
+    return parseDiffHunks(output);
+}
+/**
+ * Parse git diff output into hunks
+ */
+function parseDiffHunks(diffOutput) {
+    const hunks = [];
+    const lines = diffOutput.split('\n');
+    let currentHunk = null;
+    let oldLineNum = 0;
+    let newLineNum = 0;
+    for (const line of lines) {
+        // Hunk header: @@ -oldStart,oldLines +newStart,newLines @@
+        const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+        if (hunkMatch) {
+            if (currentHunk) {
+                hunks.push(currentHunk);
+            }
+            const oldStart = parseInt(hunkMatch[1], 10);
+            const oldLines = hunkMatch[2] ? parseInt(hunkMatch[2], 10) : 1;
+            const newStart = parseInt(hunkMatch[3], 10);
+            const newLines = hunkMatch[4] ? parseInt(hunkMatch[4], 10) : 1;
+            currentHunk = {
+                oldStart,
+                oldLines,
+                newStart,
+                newLines,
+                lines: [],
+            };
+            oldLineNum = oldStart;
+            newLineNum = newStart;
+            continue;
+        }
+        // Skip diff headers
+        if (line.startsWith('diff --git') ||
+            line.startsWith('index ') ||
+            line.startsWith('---') ||
+            line.startsWith('+++') ||
+            line.startsWith('\\')) {
+            continue;
+        }
+        // Parse diff lines
+        if (currentHunk) {
+            if (line.startsWith('+')) {
+                const diffLine = {
+                    type: 'add',
+                    content: line.substring(1),
+                    newNumber: newLineNum++,
+                };
+                currentHunk.lines.push(diffLine);
+            }
+            else if (line.startsWith('-')) {
+                const diffLine = {
+                    type: 'remove',
+                    content: line.substring(1),
+                    oldNumber: oldLineNum++,
+                };
+                currentHunk.lines.push(diffLine);
+            }
+            else if (line.startsWith(' ') || line === '') {
+                const diffLine = {
+                    type: 'context',
+                    content: line.substring(1),
+                    oldNumber: oldLineNum++,
+                    newNumber: newLineNum++,
+                };
+                currentHunk.lines.push(diffLine);
+            }
+        }
+    }
+    if (currentHunk) {
+        hunks.push(currentHunk);
+    }
+    return hunks;
+}
+/**
+ * Check if a file is binary by attempting to get its diff
+ */
+export async function isBinaryFile(repoPath, sha, filePath) {
+    try {
+        const output = await execGit(repoPath, [
+            'show', sha,
+            '--format=',
+            '--', filePath,
+        ]);
+        return output.includes('Binary files');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get file content at a specific commit
+ */
+export async function getFileContent(repoPath, sha, filePath) {
+    // Validate SHA format
+    if (!/^[0-9a-f]{4,40}$/i.test(sha)) {
+        throw new Error(`Invalid commit SHA: ${sha}`);
+    }
+    // Validate path is within repo
+    if (!validatePathInRepo(repoPath, filePath)) {
+        throw new Error('File path is outside repository');
+    }
+    // Get file content at commit
+    const output = await execGit(repoPath, ['show', `${sha}:${filePath}`]);
+    return output;
+}
+/**
+ * Check if a commit exists in a repository
+ */
+async function commitExistsInRepo(repoPath, sha) {
+    try {
+        await execGit(repoPath, ['cat-file', '-t', sha]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Find which repository contains a given commit SHA.
+ * Checks the root path first (if it's a git repo), then searches discovered repos in parallel.
+ *
+ * @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
+ */
+export async function findRepoForCommit(repoConfig, sha) {
+    // Validate SHA format
+    if (!/^[0-9a-f]{4,40}$/i.test(sha)) {
+        throw new Error(`Invalid commit SHA: ${sha}`);
+    }
+    // Check if root path is a git repo first
+    if (await isGitRepo(repoConfig.path)) {
+        if (await commitExistsInRepo(repoConfig.path, sha)) {
+            return {
+                sha,
+                repoPath: '',
+                absolutePath: repoConfig.path,
+            };
+        }
+    }
+    // If no discovered repos, commit not found
+    if (!repoConfig.gitRepos || repoConfig.gitRepos.length === 0) {
+        throw new Error(`Commit ${sha.substring(0, 7)} not found in repository "${repoConfig.name}"`);
+    }
+    // Search discovered repos in parallel
+    const results = await Promise.all(repoConfig.gitRepos.map(async (gitRepo) => {
+        if (await commitExistsInRepo(gitRepo.absolutePath, sha)) {
+            return {
+                sha,
+                repoPath: gitRepo.relativePath,
+                absolutePath: gitRepo.absolutePath,
+            };
+        }
+        return null;
+    }));
+    // Find first match
+    const found = results.find((r) => r !== null);
+    if (found) {
+        return found;
+    }
+    throw new Error(`Commit ${sha.substring(0, 7)} not found in repository "${repoConfig.name}" or any of its ${repoConfig.gitRepos.length} discovered git repos`);
+}
+/**
+ * Resolve a commit entry (string or CommitRef) to its repository information.
+ * For CommitRef objects, returns immediately (O(1)).
+ * For string SHAs, searches repositories to find the commit.
+ *
+ * @param repoConfig - The repository configuration
+ * @param commitEntry - Either a commit SHA string or a CommitRef object
+ * @returns Resolved commit information with repo path
+ */
+export async function resolveCommitRepo(repoConfig, commitEntry) {
+    // If it's a CommitRef object, we already have the repo info (O(1))
+    if (typeof commitEntry === 'object' && commitEntry.sha && commitEntry.repo) {
+        return {
+            sha: commitEntry.sha,
+            repoPath: commitEntry.repo,
+            absolutePath: join(repoConfig.path, commitEntry.repo),
+        };
+    }
+    // It's a string SHA, need to search for it
+    const sha = typeof commitEntry === 'string' ? commitEntry : commitEntry.sha;
+    return findRepoForCommit(repoConfig, sha);
+}