@lovelybunch/api 1.0.50 → 1.0.52

package/dist/lib/git-settings.d.ts

@@ -0,0 +1,7 @@
+export interface GitSettings {
+    defaultWorktreePath: string;
+}
+export declare function normalizeWorktreePath(input: string): string;
+export declare function loadGitSettings(): Promise<GitSettings>;
+export declare function saveGitSettings(settings: GitSettings): Promise<void>;
+export declare function setDefaultWorktreePath(relativePath: string): Promise<GitSettings>;

package/dist/lib/git-settings.js

@@ -0,0 +1,84 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { findNutDirectory } from './gait-path.js';
+const DEFAULT_SETTINGS = {
+    defaultWorktreePath: '../worktrees',
+};
+async function ensureNutDirectory() {
+    const nutDir = await findNutDirectory();
+    if (nutDir)
+        return nutDir;
+    const fallback = path.join(process.cwd(), '.nut');
+    await fs.mkdir(fallback, { recursive: true });
+    return fallback;
+}
+async function getConfigPath() {
+    const nutDir = await ensureNutDirectory();
+    return path.join(nutDir, 'config.json');
+}
+async function loadProjectConfig() {
+    const configPath = await getConfigPath();
+    try {
+        const raw = await fs.readFile(configPath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            return {};
+        }
+        console.warn('[git-settings] Failed to read config.json, using empty config:', error);
+        return {};
+    }
+}
+async function saveProjectConfig(config) {
+    const configPath = await getConfigPath();
+    const dir = path.dirname(configPath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+}
+export function normalizeWorktreePath(input) {
+    const trimmed = input?.trim();
+    if (!trimmed) {
+        return DEFAULT_SETTINGS.defaultWorktreePath;
+    }
+    if (path.isAbsolute(trimmed)) {
+        throw new Error('Worktree path must be relative to the project root');
+    }
+    const normalized = path.normalize(trimmed);
+    if (!normalized || normalized === '.' || normalized === '') {
+        return DEFAULT_SETTINGS.defaultWorktreePath;
+    }
+    return normalized;
+}
+export async function loadGitSettings() {
+    const config = await loadProjectConfig();
+    const configuredPath = config.git?.defaultWorktreePath;
+    if (!configuredPath) {
+        return { ...DEFAULT_SETTINGS };
+    }
+    try {
+        const normalized = normalizeWorktreePath(configuredPath);
+        return { defaultWorktreePath: normalized };
+    }
+    catch (error) {
+        console.warn('[git-settings] Invalid default worktree path in config.json, using default:', error);
+        return { ...DEFAULT_SETTINGS };
+    }
+}
+export async function saveGitSettings(settings) {
+    const config = await loadProjectConfig();
+    const normalized = normalizeWorktreePath(settings.defaultWorktreePath);
+    const next = {
+        ...config,
+        git: {
+            ...config.git,
+            defaultWorktreePath: normalized,
+        },
+    };
+    await saveProjectConfig(next);
+}
+export async function setDefaultWorktreePath(relativePath) {
+    const normalized = normalizeWorktreePath(relativePath);
+    await saveGitSettings({ defaultWorktreePath: normalized });
+    return { defaultWorktreePath: normalized };
+}

package/dist/lib/git.js

@@ -2,6 +2,7 @@ import { promisify } from 'util';
 import { execFile as _execFile } from 'child_process';
 import path from 'path';
 import { findGaitDirectory } from './gait-path.js';
+import { loadGitSettings } from './git-settings.js';
 import { promises as fs } from 'fs';
 const execFile = promisify(_execFile);
 // Base directory for worktrees under the repository root
@@ -16,7 +17,9 @@ export async function getRepoRoot() {
 }
 export async function getWorktreesBase() {
     const repoRoot = await getRepoRoot();
-    return path.join(repoRoot, 'worktrees');
+    const settings = await loadGitSettings();
+    const relativeBase = settings.defaultWorktreePath || 'worktrees';
+    return path.resolve(repoRoot, relativeBase);
 }
 export function sanitizeBranchName(name) {
     if (name.length > 120) {
@@ -31,7 +34,8 @@ export async function resolveSafeWorktreePath(name) {
     const base = await getWorktreesBase();
     const safeName = sanitizeBranchName(name);
     const resolved = path.resolve(base, safeName);
-    if (!resolved.startsWith(base)) {
+    const relative = path.relative(base, resolved);
+    if (relative.startsWith('..') || path.isAbsolute(relative)) {
         throw new Error('Invalid worktree path');
     }
     return resolved;

package/dist/lib/storage/file-storage.d.ts

@@ -15,6 +15,7 @@ export interface StorageAdapter {
 }
 export declare class FileStorageAdapter implements StorageAdapter {
     private basePath;
+    private sanitizeForYAML;
     constructor(basePath?: string);
     ensureDirectories(): Promise<void>;
     createCP(cp: ChangeProposal): Promise<void>;

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

@@ -4,6 +4,33 @@ import matter from 'gray-matter';
 import Fuse from 'fuse.js';
 export class FileStorageAdapter {
     basePath;
+    // Remove undefined values recursively to avoid YAML dump errors
+    sanitizeForYAML(value) {
+        if (value === undefined)
+            return undefined;
+        if (value === null)
+            return null;
+        if (Array.isArray(value)) {
+            return value
+                .filter((v) => v !== undefined)
+                .map((v) => this.sanitizeForYAML(v));
+        }
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+        if (typeof value === 'object') {
+            const out = {};
+            for (const [k, v] of Object.entries(value)) {
+                if (v === undefined || typeof v === 'function')
+                    continue;
+                const sanitized = this.sanitizeForYAML(v);
+                if (sanitized !== undefined)
+                    out[k] = sanitized;
+            }
+            return out;
+        }
+        return value;
+    }
     constructor(basePath) {
         if (basePath) {
             this.basePath = basePath;
@@ -31,13 +58,20 @@ export class FileStorageAdapter {
         await this.ensureDirectories();
         // Extract content from the proposal if it exists
         const { content, ...frontmatter } = cp;
+        // Normalize date fields to Date instances in case callers provide ISO strings
+        const createdAt = cp.metadata.createdAt instanceof Date
+            ? cp.metadata.createdAt
+            : new Date(cp.metadata.createdAt);
+        const updatedAt = cp.metadata.updatedAt instanceof Date
+            ? cp.metadata.updatedAt
+            : new Date(cp.metadata.updatedAt);
         // Convert the proposal to markdown with YAML frontmatter
-        const markdown = matter.stringify(content || this.getDefaultContent(cp), {
+        const frontmatterData = this.sanitizeForYAML({
             // Required fields
             id: cp.id,
             intent: cp.intent,
-            createdAt: cp.metadata.createdAt.toISOString(),
-            updatedAt: cp.metadata.updatedAt.toISOString(),
+            createdAt: createdAt.toISOString(),
+            updatedAt: updatedAt.toISOString(),
             status: cp.status,
             priority: cp.metadata.priority || 'medium',
             // Author information
@@ -61,8 +95,9 @@ export class FileStorageAdapter {
             // Metadata
             tags: cp.metadata.tags || [],
             labels: [],
-            comments: cp.comments || []
+            comments: (cp.comments || []).filter((c) => c !== undefined)
         });
+        const markdown = matter.stringify(content || this.getDefaultContent(cp), frontmatterData);
         const filePath = path.join(this.basePath, 'proposals', `${cp.id}.md`);
         await fs.writeFile(filePath, markdown, 'utf-8');
     }

package/dist/lib/terminal/terminal-manager.d.ts

@@ -10,6 +10,9 @@ export interface TerminalSession {
     enableLogging?: boolean;
     logFilePath?: string;
     backlog: string;
+    previewSockets?: Set<WebSocket>;
+    previewBuffer?: string;
+    previewFlushTimer?: NodeJS.Timeout | null;
 }
 export declare class TerminalManager {
     private sessions;
@@ -25,4 +28,6 @@ export declare class TerminalManager {
     private cleanupInactiveSessions;
     getAllSessions(): TerminalSession[];
     destroy(): void;
+    private enqueuePreviewBroadcast;
+    attachPreviewWebSocket(sessionId: string, ws: WebSocket): boolean;
 }

package/dist/lib/terminal/terminal-manager.js

@@ -114,6 +114,9 @@ export class TerminalManager {
             enableLogging,
             logFilePath,
             backlog: '',
+            previewSockets: new Set(),
+            previewBuffer: '',
+            previewFlushTimer: null,
         };
         this.sessions.set(sessionId, session);
         // Set up PTY event handlers
@@ -147,6 +150,8 @@ export class TerminalManager {
                     data: data,
                 }));
             }
+            // Broadcast to preview viewers with throttling
+            this.enqueuePreviewBroadcast(session, data);
         });
         ptyProcess.onExit((e) => {
             // Log session end if logging is enabled
@@ -261,6 +266,17 @@ export class TerminalManager {
         if (session.websocket && session.websocket.readyState === WebSocket.OPEN) {
             session.websocket.close();
         }
+        // Close all preview sockets
+        if (session.previewSockets && session.previewSockets.size > 0) {
+            for (const ws of Array.from(session.previewSockets)) {
+                try {
+                    if (ws.readyState === WebSocket.OPEN)
+                        ws.close();
+                }
+                catch { }
+            }
+            session.previewSockets.clear();
+        }
         // Kill PTY process
         try {
             session.pty.kill();
@@ -310,5 +326,68 @@ export class TerminalManager {
             clearInterval(this.cleanupInterval);
         }
     }
+    enqueuePreviewBroadcast(session, chunk) {
+        try {
+            if (!session.previewSockets || session.previewSockets.size === 0)
+                return;
+            session.previewBuffer = (session.previewBuffer || '') + chunk;
+            if (session.previewFlushTimer)
+                return;
+            session.previewFlushTimer = setTimeout(() => {
+                const payload = session.previewBuffer || '';
+                session.previewBuffer = '';
+                session.previewFlushTimer = null;
+                // Clean up closed sockets while broadcasting
+                const dead = [];
+                for (const ws of session.previewSockets) {
+                    try {
+                        if (ws.readyState === WebSocket.OPEN) {
+                            ws.send(JSON.stringify({ type: 'data', data: payload }));
+                        }
+                        else {
+                            dead.push(ws);
+                        }
+                    }
+                    catch {
+                        dead.push(ws);
+                    }
+                }
+                if (dead.length) {
+                    for (const d of dead)
+                        session.previewSockets.delete(d);
+                }
+            }, 75); // batch messages ~13fps
+        }
+        catch { }
+    }
+    attachPreviewWebSocket(sessionId, ws) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return false;
+        if (!session.previewSockets)
+            session.previewSockets = new Set();
+        session.previewSockets.add(ws);
+        session.lastActivity = new Date();
+        // On attach, send a snapshot of recent backlog (last 4KB)
+        try {
+            const backlog = session.backlog || '';
+            const sliceStart = Math.max(0, backlog.length - 4096);
+            const chunk = backlog.slice(sliceStart);
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({ type: 'snapshot', data: chunk }));
+            }
+        }
+        catch { }
+        ws.on('message', () => {
+            // Ignore messages: preview sockets are read-only
+        });
+        ws.on('close', () => {
+            session.previewSockets?.delete(ws);
+        });
+        ws.on('error', () => {
+            session.previewSockets?.delete(ws);
+        });
+        return true;
+    }
 }
 // We'll use the global manager instead of creating a direct export

package/dist/routes/api/v1/ai/route.js

@@ -2,7 +2,7 @@ import { homedir } from 'os';
 import { join } from 'path';
 import { existsSync, readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
-import { proposalsTool, listProposalsTool } from '@lovelybunch/mcp';
+import { proposalsTool, listProposalsTool, validateProposalData } from '@lovelybunch/mcp';
 import { FileStorageAdapter } from '../../../../lib/storage/file-storage.js';
 import { getAuthorInfo } from '../../../../lib/user-preferences.js';
 // Function to get global config API key as fallback
@@ -239,24 +239,62 @@ async function executeProposalsToolDirect(args, storage) {
                 }
                 // Get author info
                 const author = await getAuthorInfo();
-                // Create the proposal
-                const proposalToCreate = {
-                    ...proposal,
-                    author,
-                    status: 'draft',
-                    metadata: {
-                        ...proposal.metadata,
-                        createdAt: new Date().toISOString(),
-                        updatedAt: new Date().toISOString(),
-                        reviewers: proposal.metadata?.reviewers || [],
-                        productSpecRef: proposal.metadata?.productSpecRef || null
+                // Normalize and validate incoming proposal
+                const validatedProposal = validateProposalData(proposal);
+                // Normalize plan steps: accept strings or objects
+                const planSteps = (validatedProposal.planSteps || []).map((step, index) => {
+                    if (typeof step === 'string') {
+                        return {
+                            id: `step-${index + 1}`,
+                            description: step,
+                            status: 'pending'
+                        };
                     }
+                    return {
+                        id: step.id || `step-${index + 1}`,
+                        description: step.description || '',
+                        status: step.status || 'pending',
+                        command: step.command,
+                        expectedOutcome: step.expectedOutcome,
+                        output: step.output,
+                        error: step.error,
+                        executedAt: step.executedAt
+                    };
+                });
+                const now = new Date();
+                const newProposal = {
+                    id: validatedProposal.id || `cp-${Date.now()}`,
+                    intent: validatedProposal.intent || '',
+                    content: validatedProposal.content || '',
+                    author: {
+                        id: validatedProposal.author?.id || 'current-user',
+                        name: validatedProposal.author?.name || author.name || 'Unknown User',
+                        email: validatedProposal.author?.email || author.email || '',
+                        type: validatedProposal.author?.type || 'human'
+                    },
+                    planSteps,
+                    evidence: validatedProposal.evidence || [],
+                    policies: validatedProposal.policies || [],
+                    featureFlags: validatedProposal.featureFlags || [],
+                    experiments: validatedProposal.experiments || [],
+                    telemetryContracts: validatedProposal.telemetryContracts || [],
+                    releasePlan: validatedProposal.releasePlan || { strategy: 'immediate' },
+                    status: validatedProposal.status || 'draft',
+                    metadata: {
+                        createdAt: now,
+                        updatedAt: now,
+                        reviewers: validatedProposal.metadata?.reviewers || [],
+                        aiInteractions: validatedProposal.metadata?.aiInteractions || [],
+                        tags: validatedProposal.metadata?.tags || [],
+                        priority: validatedProposal.metadata?.priority || 'medium'
+                    },
+                    productSpecRef: validatedProposal.productSpecRef
                 };
-                await storage.createCP(proposalToCreate);
+                await storage.createCP(newProposal);
                 return {
                     success: true,
-                    data: proposalToCreate,
-                    message: `Created proposal ${proposalToCreate.id}`
+                    data: newProposal,
+                    message: `Created proposal ${newProposal.id} (${newProposal.intent})`
                 };
             }
             case 'update': {

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

@@ -1,6 +1,33 @@
 import { Hono } from 'hono';
 import { getRepoStatus, listBranches, createBranch, deleteBranch, pushCurrent, pullCurrent, listWorktrees, addWorktree, removeWorktree, commitInWorktree, pushWorktree, pullWorktree, } from '../../../../lib/git.js';
+import { loadGitSettings, setDefaultWorktreePath } from '../../../../lib/git-settings.js';
 const app = new Hono();
+// Settings
+app.get('/settings', async (c) => {
+    try {
+        const settings = await loadGitSettings();
+        return c.json({ success: true, data: settings });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message || 'Failed to load git settings' } }, 500);
+    }
+});
+app.put('/settings', async (c) => {
+    try {
+        const body = await c.req.json();
+        const path = body?.defaultWorktreePath;
+        if (typeof path !== 'string' || !path.trim()) {
+            return c.json({ success: false, error: { message: 'defaultWorktreePath is required' } }, 400);
+        }
+        const settings = await setDefaultWorktreePath(path);
+        return c.json({ success: true, data: settings });
+    }
+    catch (e) {
+        const message = e?.message || 'Failed to update git settings';
+        const status = /relative to the project root/i.test(message) ? 400 : 500;
+        return c.json({ success: false, error: { message } }, status);
+    }
+});
 // Status
 app.get('/status', async (c) => {
     try {

package/dist/routes/api/v1/mcp/config/index.d.ts

@@ -0,0 +1 @@
+export { default } from './route.js';

package/dist/routes/api/v1/mcp/config/index.js

@@ -0,0 +1 @@
+export { default } from './route.js';

package/dist/routes/api/v1/mcp/config/route.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/mcp/config/route.js

@@ -0,0 +1,59 @@
+import { Hono } from 'hono';
+import { promises as fs } from 'fs';
+import path from 'path';
+const app = new Hono();
+const getMcpConfigPath = () => {
+    const gaitPath = path.join(process.cwd(), '.gait');
+    return path.join(gaitPath, 'mcp', 'config.json');
+};
+const ensureMcpDirectory = async () => {
+    const gaitPath = path.join(process.cwd(), '.gait');
+    const mcpPath = path.join(gaitPath, 'mcp');
+    try {
+        await fs.access(mcpPath);
+    }
+    catch {
+        await fs.mkdir(mcpPath, { recursive: true });
+    }
+};
+// GET /api/v1/mcp/config - Get MCP configuration
+app.get('/', async (c) => {
+    try {
+        await ensureMcpDirectory();
+        const configPath = getMcpConfigPath();
+        try {
+            const configData = await fs.readFile(configPath, 'utf-8');
+            const config = JSON.parse(configData);
+            return c.json(config);
+        }
+        catch (error) {
+            // If file doesn't exist or is invalid, return empty config
+            return c.json({});
+        }
+    }
+    catch (error) {
+        console.error('Error reading MCP config:', error);
+        return c.json({ error: 'Failed to read MCP configuration' }, 500);
+    }
+});
+// PUT /api/v1/mcp/config - Update MCP configuration
+app.put('/', async (c) => {
+    try {
+        const body = await c.req.json();
+        await ensureMcpDirectory();
+        const configPath = getMcpConfigPath();
+        // Validate the configuration structure
+        if (typeof body !== 'object') {
+            return c.json({ error: 'Invalid configuration format' }, 400);
+        }
+        // Write the configuration to file
+        const configData = JSON.stringify(body, null, 2);
+        await fs.writeFile(configPath, configData, 'utf-8');
+        return c.json({ message: 'MCP configuration updated successfully' });
+    }
+    catch (error) {
+        console.error('Error updating MCP config:', error);
+        return c.json({ error: 'Failed to update MCP configuration' }, 500);
+    }
+});
+export default app;

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

@@ -40,10 +40,10 @@ app.get('/', async (c) => {
             }
         }
         const names = Object.keys(externalServers);
-        // Add built-in tools
+        // Add built-in tools (include full JSON schema for parameters)
         const builtInTools = {
-            proposals: proposalsTool,
-            listProposals: listProposalsTool
+            change_proposals: proposalsTool,
+            list_proposals: listProposalsTool
         };
         return c.json({
             success: true,
@@ -57,6 +57,25 @@ app.get('/', async (c) => {
         return c.json({ success: false, error: 'Failed to load MCP servers', servers: [], tools: {} }, 500);
     }
 });
+/**
+ * GET /api/v1/mcp/schema
+ * Returns the JSON Schemas for built-in tools so LLMs and clients can construct valid calls.
+ */
+app.get('/schema', async (c) => {
+    try {
+        const schema = {
+            tools: {
+                change_proposals: proposalsTool,
+                list_proposals: listProposalsTool
+            }
+        };
+        return c.json(schema);
+    }
+    catch (err) {
+        console.error('Error returning MCP schema:', err);
+        return c.json({ error: 'Failed to load MCP schema' }, 500);
+    }
+});
 /**
  * POST /api/v1/mcp/execute
  * Execute a tool call

package/dist/routes/api/v1/terminal/sessions/route.js

@@ -1,12 +1,51 @@
 import { getGlobalTerminalManager } from '../../../../../lib/terminal/global-manager.js';
+// Lightweight ANSI escape sequence stripper to keep preview readable
+// This avoids adding a dependency just for previews
+const ANSI_REGEX = /[\u001B\u009B][[\]()#;?]*(?:\d{1,4}(?:;\d{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+function stripAnsi(input) {
+    try {
+        return input.replace(ANSI_REGEX, '');
+    }
+    catch {
+        return input;
+    }
+}
+// Create a small preview from the backlog without scanning the entire string
+function buildPreview(backlog, lines, maxBytes, strip) {
+    if (!backlog)
+        return [];
+    // Take only the last maxBytes to avoid processing the full backlog
+    const sliceStart = Math.max(0, backlog.length - maxBytes);
+    let chunk = backlog.slice(sliceStart);
+    // Normalize newlines for readability
+    chunk = chunk.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    // Strip ANSI sequences unless colorized previews are requested
+    if (strip) {
+        chunk = stripAnsi(chunk);
+    }
+    const parts = chunk.split('\n');
+    const tail = parts.slice(-Math.max(1, lines));
+    return tail;
+}
 export async function GET(c) {
     try {
         const url = new URL(c.req.url);
         const searchParams = url.searchParams;
         const proposalId = searchParams.get('proposalId');
+        const sessionId = searchParams.get('sessionId');
+        const withPreview = ['1', 'true', 'yes'].includes((searchParams.get('withPreview') || '').toLowerCase());
+        const linesParam = parseInt(searchParams.get('lines') || '0', 10);
+        const previewLines = Number.isFinite(linesParam) && linesParam > 0 ? Math.min(linesParam, 10) : 4; // cap at 10
+        const maxBytesParam = parseInt(searchParams.get('previewBytes') || '0', 10);
+        const previewBytes = Number.isFinite(maxBytesParam) && maxBytesParam > 0 ? Math.min(maxBytesParam, 8192) : 4096; // cap at 8KB
+        const colorize = ['1', 'true', 'yes'].includes((searchParams.get('colorize') || '').toLowerCase());
         const terminalManager = getGlobalTerminalManager();
         let sessions;
-        if (proposalId) {
+        if (sessionId) {
+            const s = terminalManager.getSession(sessionId);
+            sessions = s ? [s] : [];
+        }
+        else if (proposalId) {
             sessions = terminalManager.getSessionsByProposal(proposalId);
         }
         else {
@@ -19,6 +58,9 @@ export async function GET(c) {
             createdAt: session.createdAt,
             lastActivity: session.lastActivity,
             connected: !!session.websocket,
+            ...(withPreview
+                ? { preview: buildPreview(session.backlog || '', previewLines, previewBytes, !colorize) }
+                : {}),
         }));
         return c.json({ sessions: sessionInfo });
     }

package/dist/server-with-static.js

@@ -52,6 +52,28 @@ app.get('/ws/terminal/:sessionId', upgradeWebSocket((c) => ({
         console.error('WebSocket error:', evt);
     }
 })));
+// WebSocket route for terminal preview sessions (read-only viewers)
+app.get('/ws/terminal-preview/:sessionId', upgradeWebSocket((c) => ({
+    onOpen: (_evt, ws) => {
+        const sessionId = c.req.param('sessionId');
+        const terminalManager = getGlobalTerminalManager();
+        const rawWs = ws.raw;
+        if (!rawWs) {
+            try {
+                ws.close(1000, 'WebSocket error');
+            }
+            catch { }
+            return;
+        }
+        const success = terminalManager.attachPreviewWebSocket(sessionId, rawWs);
+        if (!success) {
+            try {
+                ws.close(1000, 'Session not found');
+            }
+            catch { }
+        }
+    },
+})));
 // Import and register API routes
 import proposals from './routes/api/v1/proposals/index.js';
 import terminalSessions from './routes/api/v1/terminal/sessions/index.js';