@lovelybunch/api 1.0.24 → 1.0.27

package/dist/lib/gait-path.d.ts

@@ -1,25 +1,13 @@
 /**
- * Get the base path for .gait directory based on environment
- *
- * Priority order:
- * 1. Explicit basePath parameter
- * 2. Dev mode: GAIT_DEV_ROOT environment variable
- * 3. Production mode: GAIT_DATA_PATH environment variable
- * 4. Fallback: current working directory
+ * Find the .gait directory by traversing up from the current working directory
+ * If GAIT_DATA_PATH is set (from CLI), use that instead
  */
-export declare function getGaitBasePath(basePath?: string): string;
+export declare function findGaitDirectory(startDir?: string): Promise<string | null>;
 /**
- * Get the full path to a specific .gait subdirectory
+ * Get the path to a context file, automatically finding the .gait directory
  */
-export declare function getGaitPath(subdirectory: string, basePath?: string): string;
+export declare function getContextFilePath(fileName: string): Promise<string | null>;
 /**
- * Common .gait subdirectories
+ * Get the .gait config to read storage path settings
  */
-export declare const GAIT_PATHS: {
-    readonly proposals: () => string;
-    readonly context: () => string;
-    readonly agents: () => string;
-    readonly resources: () => string;
-    readonly chats: () => string;
-    readonly config: () => string;
-};
+export declare function getGaitConfig(): Promise<any | null>;

package/dist/lib/gait-path.js

@@ -1,45 +1,57 @@
+import { promises as fs } from 'fs';
 import path from 'path';
 /**
- * Get the base path for .gait directory based on environment
- *
- * Priority order:
- * 1. Explicit basePath parameter
- * 2. Dev mode: GAIT_DEV_ROOT environment variable
- * 3. Production mode: GAIT_DATA_PATH environment variable
- * 4. Fallback: current working directory
+ * Find the .gait directory by traversing up from the current working directory
+ * If GAIT_DATA_PATH is set (from CLI), use that instead
  */
-export function getGaitBasePath(basePath) {
-    if (basePath) {
-        return basePath;
+export async function findGaitDirectory(startDir) {
+    // If running from CLI (gait serve), use the directory where command was run
+    if (process.env.GAIT_DATA_PATH) {
+        const gaitPath = path.join(process.env.GAIT_DATA_PATH, '.gait');
+        try {
+            await fs.access(gaitPath);
+            return gaitPath;
+        }
+        catch {
+            // Fall through to directory traversal
+        }
     }
-    if (process.env.NODE_ENV === 'development' && process.env.GAIT_DEV_ROOT) {
-        // Dev mode: use project root .gait directory
-        return process.env.GAIT_DEV_ROOT;
-    }
-    else if (process.env.GAIT_DATA_PATH) {
-        // Production mode: use GAIT_DATA_PATH (set by CLI)
-        return path.resolve(process.env.GAIT_DATA_PATH, '.gait');
-    }
-    else {
-        // Fallback: use current directory .gait
-        return path.resolve(process.cwd(), '.gait');
+    // Otherwise traverse up from start directory
+    let currentDir = startDir || process.cwd();
+    while (currentDir !== path.parse(currentDir).root) {
+        const gaitPath = path.join(currentDir, '.gait');
+        try {
+            await fs.access(gaitPath);
+            return gaitPath;
+        }
+        catch {
+            currentDir = path.dirname(currentDir);
+        }
     }
+    return null;
 }
 /**
- * Get the full path to a specific .gait subdirectory
+ * Get the path to a context file, automatically finding the .gait directory
  */
-export function getGaitPath(subdirectory, basePath) {
-    const base = getGaitBasePath(basePath);
-    return path.join(base, subdirectory);
+export async function getContextFilePath(fileName) {
+    const gaitDir = await findGaitDirectory();
+    if (!gaitDir)
+        return null;
+    return path.join(gaitDir, 'context', fileName);
 }
 /**
- * Common .gait subdirectories
+ * Get the .gait config to read storage path settings
  */
-export const GAIT_PATHS = {
-    proposals: () => getGaitPath('proposals'),
-    context: () => getGaitPath('context'),
-    agents: () => getGaitPath('agents'),
-    resources: () => getGaitPath('resources'),
-    chats: () => getGaitPath('chats'),
-    config: () => getGaitPath(''),
-};
+export async function getGaitConfig() {
+    const gaitDir = await findGaitDirectory();
+    if (!gaitDir)
+        return null;
+    const configPath = path.join(gaitDir, 'config.json');
+    try {
+        const config = await fs.readFile(configPath, 'utf-8');
+        return JSON.parse(config);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/git.d.ts

@@ -0,0 +1,48 @@
+export declare function getRepoRoot(): Promise<string>;
+export declare function getWorktreesBase(): Promise<string>;
+export declare function sanitizeBranchName(name: string): string;
+export declare function resolveSafeWorktreePath(name: string): Promise<string>;
+export declare function runGit(args: string[], opts?: {
+    cwd?: string;
+}): Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+export declare function getRepoStatus(): Promise<{
+    branch: string;
+    ahead: number;
+    behind: number;
+    upstream?: string;
+    head?: string;
+    changes: {
+        path: string;
+        status: string;
+    }[];
+}>;
+export declare function listBranches(): Promise<{
+    name: string;
+    current: boolean;
+}[]>;
+export declare function createBranch(name: string, from?: string): Promise<void>;
+export declare function deleteBranch(name: string): Promise<void>;
+export declare function pushCurrent(): Promise<string>;
+export declare function pullCurrent(): Promise<string>;
+export interface WorktreeInfo {
+    name: string;
+    path: string;
+    branch: string;
+    head?: string;
+    locked: boolean;
+}
+export declare function listWorktrees(): Promise<WorktreeInfo[]>;
+export declare function addWorktree(branch: string, from?: string): Promise<{
+    path: string;
+    branch: string;
+    from?: string;
+}>;
+export declare function removeWorktree(nameOrPath: string): Promise<void>;
+export declare function commitInWorktree(name: string, message: string, files?: string[]): Promise<{
+    commitHash?: string;
+}>;
+export declare function pushWorktree(name: string): Promise<string>;
+export declare function pullWorktree(name: string): Promise<string>;

package/dist/lib/git.js

@@ -0,0 +1,201 @@
+import { promisify } from 'util';
+import { execFile as _execFile } from 'child_process';
+import path from 'path';
+import { findGaitDirectory } from './gait-path.js';
+import { promises as fs } from 'fs';
+const execFile = promisify(_execFile);
+// Base directory for worktrees under the repository root
+export async function getRepoRoot() {
+    // Use .gait discovery to find project root, then go up one level
+    const gaitDir = await findGaitDirectory();
+    if (!gaitDir) {
+        // Fallback to process cwd
+        return process.cwd();
+    }
+    return path.dirname(gaitDir);
+}
+export async function getWorktreesBase() {
+    const repoRoot = await getRepoRoot();
+    return path.join(repoRoot, 'worktrees');
+}
+export function sanitizeBranchName(name) {
+    if (name.length > 120) {
+        throw new Error('Invalid branch/worktree name: too long');
+    }
+    if (!/^[A-Za-z0-9/_\-\.]+$/.test(name)) {
+        throw new Error('Invalid branch/worktree name');
+    }
+    return name;
+}
+export async function resolveSafeWorktreePath(name) {
+    const base = await getWorktreesBase();
+    const safeName = sanitizeBranchName(name);
+    const resolved = path.resolve(base, safeName);
+    if (!resolved.startsWith(base)) {
+        throw new Error('Invalid worktree path');
+    }
+    return resolved;
+}
+export async function runGit(args, opts) {
+    const repoRoot = await getRepoRoot();
+    const cwd = opts?.cwd || repoRoot;
+    return execFile('git', args, { cwd, maxBuffer: 10 * 1024 * 1024 });
+}
+// --- Status ---
+export async function getRepoStatus() {
+    const { stdout } = await runGit(['status', '--porcelain=v1', '-b']);
+    const lines = stdout.trim().split('\n').filter(Boolean);
+    let branch = 'unknown';
+    let ahead = 0;
+    let behind = 0;
+    let upstream;
+    const changes = [];
+    for (const line of lines) {
+        if (line.startsWith('## ')) {
+            // Example: ## main...origin/main [ahead 1, behind 2]
+            const m = line.match(/^##\s+([^\.\s]+)(?:\.\.\.([^\s]+))?(?:.*?\bahead (\d+))?(?:.*?\bbehind (\d+))?/);
+            if (m) {
+                branch = m[1];
+                upstream = m[2] || undefined;
+                ahead = m[3] ? parseInt(m[3], 10) : 0;
+                behind = m[4] ? parseInt(m[4], 10) : 0;
+            }
+            else {
+                // Fallback to just branch name after ##
+                branch = line.slice(3).trim();
+            }
+        }
+        else {
+            // Porcelain entry e.g. " M src/app.ts" or "?? README.md"
+            const status = line.slice(0, 2).trim() || line.slice(0, 2);
+            const file = line.slice(3);
+            changes.push({ path: file, status });
+        }
+    }
+    let head;
+    try {
+        const { stdout: sha } = await runGit(['rev-parse', 'HEAD']);
+        head = sha.trim();
+    }
+    catch {
+        // ignore if no commits yet
+    }
+    return { branch, ahead, behind, upstream, head, changes };
+}
+// --- Branches ---
+export async function listBranches() {
+    const { stdout } = await runGit(['branch', '--list']);
+    return stdout
+        .split('\n')
+        .filter(Boolean)
+        .map((l) => {
+        const current = l.trim().startsWith('* ');
+        const name = l.replace('*', '').trim();
+        return { name, current };
+    });
+}
+export async function createBranch(name, from = 'main') {
+    const safe = sanitizeBranchName(name);
+    await runGit(['branch', safe, from]);
+}
+export async function deleteBranch(name) {
+    const safe = sanitizeBranchName(name);
+    await runGit(['branch', '-D', safe]);
+}
+// --- Push / Pull ---
+export async function pushCurrent() {
+    const { stdout } = await runGit(['push']);
+    return stdout;
+}
+export async function pullCurrent() {
+    const { stdout } = await runGit(['pull']);
+    return stdout;
+}
+export async function listWorktrees() {
+    const { stdout } = await runGit(['worktree', 'list', '--porcelain']);
+    // Parse porcelain groups separated by blank lines with fields: worktree <path>, HEAD <sha>, branch <refs/heads/x>, locked
+    const entries = [];
+    const blocks = stdout.split('\n\n').map((b) => b.trim()).filter(Boolean);
+    for (const block of blocks) {
+        const lines = block.split('\n');
+        let wtPath = '';
+        let head;
+        let branchRef = '';
+        let locked = false;
+        for (const l of lines) {
+            const [k, ...rest] = l.split(' ');
+            const v = rest.join(' ');
+            if (k === 'worktree')
+                wtPath = v;
+            if (k === 'HEAD')
+                head = v;
+            if (k === 'branch')
+                branchRef = v;
+            if (k === 'locked')
+                locked = true;
+        }
+        const branch = branchRef.replace('refs/heads/', '');
+        const name = path.basename(wtPath);
+        entries.push({ name, path: wtPath, branch, head, locked });
+    }
+    return entries;
+}
+async function getWorktreeByName(name) {
+    const all = await listWorktrees();
+    return all.find((w) => w.name === name || w.branch === name);
+}
+export async function addWorktree(branch, from) {
+    const safeBranch = sanitizeBranchName(branch);
+    const wtPath = await resolveSafeWorktreePath(safeBranch);
+    const base = await getWorktreesBase();
+    await fs.mkdir(base, { recursive: true });
+    // Ensure parent directory exists
+    // Use git worktree add -b when creating from another branch
+    if (from) {
+        await runGit(['worktree', 'add', '-b', safeBranch, wtPath, from]);
+    }
+    else {
+        await runGit(['worktree', 'add', wtPath, safeBranch]);
+    }
+    return { path: wtPath, branch: safeBranch, from };
+}
+export async function removeWorktree(nameOrPath) {
+    // If a named worktree exists, use its actual path; otherwise treat as path relative to base
+    let targetPath = nameOrPath;
+    if (!path.isAbsolute(nameOrPath)) {
+        const found = await getWorktreeByName(nameOrPath);
+        if (found) {
+            targetPath = found.path;
+        }
+        else {
+            targetPath = await resolveSafeWorktreePath(nameOrPath);
+        }
+    }
+    await runGit(['worktree', 'remove', targetPath]);
+}
+export async function commitInWorktree(name, message, files) {
+    const found = await getWorktreeByName(name);
+    const wtPath = found ? found.path : await resolveSafeWorktreePath(name);
+    // git -C <worktree> add ... && commit -m
+    if (files && files.length > 0) {
+        await runGit(['-C', wtPath, 'add', ...files]);
+    }
+    else {
+        await runGit(['-C', wtPath, 'add', '-A']);
+    }
+    await runGit(['-C', wtPath, 'commit', '-m', message]);
+    const { stdout } = await runGit(['-C', wtPath, 'rev-parse', 'HEAD']);
+    return { commitHash: stdout.trim() };
+}
+export async function pushWorktree(name) {
+    const found = await getWorktreeByName(name);
+    const wtPath = found ? found.path : await resolveSafeWorktreePath(name);
+    const { stdout } = await runGit(['-C', wtPath, 'push']);
+    return stdout;
+}
+export async function pullWorktree(name) {
+    const found = await getWorktreeByName(name);
+    const wtPath = found ? found.path : await resolveSafeWorktreePath(name);
+    const { stdout } = await runGit(['-C', wtPath, 'pull']);
+    return stdout;
+}

package/dist/lib/storage/file-storage.js

@@ -2,11 +2,24 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import matter from 'gray-matter';
 import Fuse from 'fuse.js';
-import { getGaitPath } from '../gait-path.js';
 export class FileStorageAdapter {
     basePath;
     constructor(basePath) {
-        this.basePath = basePath || getGaitPath('proposals');
+        if (basePath) {
+            this.basePath = basePath;
+        }
+        else if (process.env.NODE_ENV === 'development' && process.env.GAIT_DEV_ROOT) {
+            // Dev mode: use project root .gait directory
+            this.basePath = process.env.GAIT_DEV_ROOT;
+        }
+        else if (process.env.GAIT_DATA_PATH) {
+            // Production mode: use GAIT_DATA_PATH (set by CLI)
+            this.basePath = path.join(process.env.GAIT_DATA_PATH, '.gait');
+        }
+        else {
+            // Fallback: use current directory .gait
+            this.basePath = '.gait';
+        }
     }
     async ensureDirectories() {
         const dirs = ['proposals', 'specs', 'flags', 'experiments', 'templates'];

package/dist/routes/api/v1/git/index.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default app;

package/dist/routes/api/v1/git/index.js

@@ -0,0 +1,175 @@
+import { Hono } from 'hono';
+import { getRepoStatus, listBranches, createBranch, deleteBranch, pushCurrent, pullCurrent, listWorktrees, addWorktree, removeWorktree, commitInWorktree, pushWorktree, pullWorktree, } from '../../../../lib/git.js';
+const app = new Hono();
+// Status
+app.get('/status', async (c) => {
+    try {
+        const status = await getRepoStatus();
+        return c.json({ success: true, data: status });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message } }, 500);
+    }
+});
+// Branches
+app.get('/branches', async (c) => {
+    try {
+        const branches = await listBranches();
+        return c.json({ success: true, data: branches });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message } }, 500);
+    }
+});
+app.post('/branches', async (c) => {
+    try {
+        const body = await c.req.json();
+        const name = String(body?.name);
+        const from = body?.from ? String(body.from) : 'main';
+        if (!name)
+            return c.json({ success: false, error: { message: 'name required' } }, 400);
+        await createBranch(name, from);
+        return c.json({ success: true, data: { created: name, from } });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message } }, 500);
+    }
+});
+app.delete('/branches/:branch', async (c) => {
+    try {
+        const name = c.req.param('branch');
+        await deleteBranch(name);
+        return c.json({ success: true, data: { deleted: name } });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message } }, 500);
+    }
+});
+// Commits (in current repo root)
+app.post('/commits', async (c) => {
+    try {
+        const body = await c.req.json();
+        const message = String(body?.message || '');
+        const files = Array.isArray(body?.files) ? body.files.map(String) : undefined;
+        if (!message)
+            return c.json({ success: false, error: { message: 'message required' } }, 400);
+        // Use repo root, add files or all, then commit
+        // Reuse worktree commit logic with special name? Simpler: do add/commit at repo root using git.ts helpers
+        // Minimal inline since helpers are worktree-centric
+        const { runGit } = await import('../../../../lib/git.js');
+        if (files && files.length > 0) {
+            await runGit(['add', ...files]);
+        }
+        else {
+            await runGit(['add', '-A']);
+        }
+        await runGit(['commit', '-m', message]);
+        const { stdout } = await runGit(['rev-parse', 'HEAD']);
+        return c.json({ success: true, data: { message, files: files ?? null, commitHash: stdout.trim() } });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message } }, 500);
+    }
+});
+// Push / Pull (current)
+app.post('/push', async (c) => {
+    try {
+        const result = await pushCurrent();
+        return c.json({ success: true, data: { result } });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message } }, 500);
+    }
+});
+app.post('/pull', async (c) => {
+    try {
+        const result = await pullCurrent();
+        return c.json({ success: true, data: { result } });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message } }, 500);
+    }
+});
+// Worktrees
+app.get('/worktrees', async (c) => {
+    try {
+        const data = await listWorktrees();
+        return c.json({ success: true, data });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message } }, 500);
+    }
+});
+app.post('/worktrees', async (c) => {
+    try {
+        const body = await c.req.json();
+        const branch = String(body?.branch || '');
+        const from = body?.from ? String(body.from) : undefined;
+        if (!branch)
+            return c.json({ success: false, error: { message: 'branch required' } }, 400);
+        const added = await addWorktree(branch, from);
+        return c.json({ success: true, data: { added } });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message } }, 500);
+    }
+});
+app.get('/worktrees/:name', async (c) => {
+    try {
+        const name = c.req.param('name');
+        const all = await listWorktrees();
+        const found = all.find((w) => w.name === name);
+        if (!found)
+            return c.json({ success: false, error: { message: 'Not found' } }, 404);
+        return c.json({ success: true, data: found });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message } }, 500);
+    }
+});
+app.delete('/worktrees/:name', async (c) => {
+    try {
+        const name = c.req.param('name');
+        await removeWorktree(name);
+        return c.json({ success: true, data: { removed: name } });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message } }, 500);
+    }
+});
+app.post('/worktrees/:name/commit', async (c) => {
+    try {
+        const name = c.req.param('name');
+        const body = await c.req.json();
+        const message = String(body?.message || '');
+        const files = Array.isArray(body?.files) ? body.files.map(String) : undefined;
+        if (!message)
+            return c.json({ success: false, error: { message: 'message required' } }, 400);
+        const res = await commitInWorktree(name, message, files);
+        return c.json({ success: true, data: { worktree: name, message, files: files ?? null, ...res } });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message } }, 500);
+    }
+});
+app.post('/worktrees/:name/push', async (c) => {
+    try {
+        const name = c.req.param('name');
+        const result = await pushWorktree(name);
+        return c.json({ success: true, data: { worktree: name, result } });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message } }, 500);
+    }
+});
+app.post('/worktrees/:name/pull', async (c) => {
+    try {
+        const name = c.req.param('name');
+        const result = await pullWorktree(name);
+        return c.json({ success: true, data: { worktree: name, result } });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message } }, 500);
+    }
+});
+export default app;

package/dist/server.js

@@ -64,6 +64,7 @@ import config from './routes/api/v1/config/index.js';
 import user from './routes/api/v1/user/index.js';
 import agents from './routes/api/v1/agents/index.js';
 import agentsById from './routes/api/v1/agents/[id]/index.js';
+import git from './routes/api/v1/git/index.js';
 // Register API routes
 app.route('/api/v1/proposals', proposals);
 app.route('/api/v1/terminal/sessions', terminalSessions);
@@ -81,6 +82,7 @@ app.route('/api/v1/config', config);
 app.route('/api/v1/user', user);
 app.route('/api/v1/agents', agents);
 app.route('/api/v1/agents/:id', agentsById);
+app.route('/api/v1/git', git);
 // Health check endpoint
 app.get('/health', (c) => {
     return c.json({ status: 'ok', timestamp: new Date().toISOString() });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lovelybunch/api",
-  "version": "1.0.24",
+  "version": "1.0.27",
   "type": "module",
   "main": "dist/server-with-static.js",
   "exports": {
@@ -32,8 +32,8 @@
   "dependencies": {
     "@hono/node-server": "^1.13.7",
     "@hono/node-ws": "^1.0.6",
-    "@lovelybunch/core": "^1.0.24",
-    "@lovelybunch/types": "^1.0.24",
+    "@lovelybunch/core": "^1.0.27",
+    "@lovelybunch/types": "^1.0.27",
     "dotenv": "^17.2.1",
     "fuse.js": "^7.0.0",
     "gray-matter": "^4.0.3",