@lovelybunch/api 1.0.69-alpha.1 → 1.0.69-alpha.10

package/dist/lib/git.d.ts

@@ -43,7 +43,8 @@ export declare function getCredentialConfig(): Promise<{
     helper?: string;
     origin?: string;
 }>;
-export declare function storeCredentials(username: string, password: string): Promise<void>;
+export declare function setRemoteUrl(remoteUrl: string): Promise<void>;
+export declare function storeCredentials(username: string, password: string, remoteUrl?: string): Promise<void>;
 export interface WorktreeInfo {
     name: string;
     path: string;
@@ -63,4 +64,31 @@ export declare function commitInWorktree(name: string, message: string, files?:
 }>;
 export declare function pushWorktree(name: string): Promise<string>;
 export declare function pullWorktree(name: string, strategy?: PullStrategy): Promise<string>;
+export interface CommitFileChange {
+    path: string;
+    status: string;
+    insertions: number;
+    deletions: number;
+}
+export interface CommitDetails {
+    sha: string;
+    message: string;
+    author: {
+        name: string;
+        email: string;
+        date: string;
+    };
+    committer: {
+        name: string;
+        email: string;
+        date: string;
+    };
+    branch?: string;
+    filesChanged: number;
+    insertions: number;
+    deletions: number;
+    files: CommitFileChange[];
+}
+export declare function getCommitDetails(sha: string): Promise<CommitDetails>;
+export declare function getFileDiff(sha: string, filepath: string): Promise<string>;
 export {};

package/dist/lib/git.js

@@ -211,10 +211,41 @@ export async function getCredentialConfig() {
         return {};
     }
 }
-export async function storeCredentials(username, password) {
+export async function setRemoteUrl(remoteUrl) {
+    // Validate the remote URL
+    if (!remoteUrl.trim()) {
+        throw new Error('Remote URL is required');
+    }
+    const trimmed = remoteUrl.trim();
+    // Check if it's a valid URL format
+    if (!trimmed.startsWith('https://') && !trimmed.startsWith('http://') && !trimmed.startsWith('git@')) {
+        throw new Error('Remote URL must start with https://, http://, or git@');
+    }
+    // Check if origin already exists
+    try {
+        await runGit(['config', '--get', 'remote.origin.url']);
+        // If we get here, origin exists, so update it
+        await runGit(['remote', 'set-url', 'origin', trimmed]);
+    }
+    catch {
+        // Origin doesn't exist, add it
+        await runGit(['remote', 'add', 'origin', trimmed]);
+    }
+}
+export async function storeCredentials(username, password, remoteUrl) {
+    // If a remote URL is provided, set it first
+    if (remoteUrl && remoteUrl.trim()) {
+        await setRemoteUrl(remoteUrl);
+    }
     // Get remote URL to determine protocol and host
-    const { stdout: remoteUrl } = await runGit(['config', '--get', 'remote.origin.url']);
-    const remote = remoteUrl.trim();
+    let remote;
+    try {
+        const { stdout: remoteUrlOutput } = await runGit(['config', '--get', 'remote.origin.url']);
+        remote = remoteUrlOutput.trim();
+    }
+    catch {
+        throw new Error('No git remote configured. Please provide a remote URL.');
+    }
     // Parse the remote URL to extract protocol and host
     let protocol = 'https';
     let host = '';
@@ -366,3 +397,114 @@ export async function pullWorktree(name, strategy = 'rebase') {
     const { stdout } = await runGit(args, { timeout: 30000 }); // 30 second timeout
     return stdout;
 }
+export async function getCommitDetails(sha) {
+    // Get commit metadata
+    const { stdout: metaOutput } = await runGit([
+        'show',
+        '--format=%H%n%an%n%ae%n%aI%n%cn%n%ce%n%cI%n%B',
+        '--no-patch',
+        sha
+    ]);
+    const lines = metaOutput.trim().split('\n');
+    const commitSha = lines[0];
+    const authorName = lines[1];
+    const authorEmail = lines[2];
+    const authorDate = lines[3];
+    const committerName = lines[4];
+    const committerEmail = lines[5];
+    const committerDate = lines[6];
+    const message = lines.slice(7).join('\n').trim();
+    // Get file changes with status
+    const { stdout: filesOutput } = await runGit([
+        'diff-tree',
+        '--no-commit-id',
+        '--name-status',
+        '-r',
+        sha
+    ]);
+    // Get numstat for insertions/deletions per file
+    const { stdout: numstatOutput } = await runGit([
+        'show',
+        '--numstat',
+        '--format=',
+        sha
+    ]);
+    // Parse file changes
+    const fileStatusMap = new Map();
+    filesOutput.trim().split('\n').filter(Boolean).forEach((line) => {
+        const [status, ...pathParts] = line.split('\t');
+        const path = pathParts.join('\t'); // Handle filenames with tabs
+        fileStatusMap.set(path, status);
+    });
+    const files = [];
+    let totalInsertions = 0;
+    let totalDeletions = 0;
+    numstatOutput.trim().split('\n').filter(Boolean).forEach((line) => {
+        const parts = line.split('\t');
+        if (parts.length >= 3) {
+            const insertions = parts[0] === '-' ? 0 : parseInt(parts[0], 10);
+            const deletions = parts[1] === '-' ? 0 : parseInt(parts[1], 10);
+            const path = parts.slice(2).join('\t');
+            const status = fileStatusMap.get(path) || 'M';
+            files.push({
+                path,
+                status,
+                insertions,
+                deletions
+            });
+            totalInsertions += insertions;
+            totalDeletions += deletions;
+        }
+    });
+    // Try to get branch name (may not always be available)
+    let branch;
+    try {
+        const { stdout: branchOutput } = await runGit([
+            'branch',
+            '--contains',
+            sha,
+            '--format=%(refname:short)'
+        ]);
+        const branches = branchOutput.trim().split('\n').filter(Boolean);
+        branch = branches[0]; // Use first branch that contains this commit
+    }
+    catch {
+        // Branch info not available
+    }
+    return {
+        sha: commitSha,
+        message,
+        author: {
+            name: authorName,
+            email: authorEmail,
+            date: authorDate
+        },
+        committer: {
+            name: committerName,
+            email: committerEmail,
+            date: committerDate
+        },
+        branch,
+        filesChanged: files.length,
+        insertions: totalInsertions,
+        deletions: totalDeletions,
+        files
+    };
+}
+export async function getFileDiff(sha, filepath) {
+    const { stdout } = await runGit([
+        'show',
+        `${sha}:${filepath}`,
+        '--',
+        filepath
+    ]);
+    // Get the actual diff for this file
+    const { stdout: diffOutput } = await runGit([
+        'show',
+        '--format=',
+        sha,
+        '--',
+        filepath
+    ]);
+    return diffOutput;
+}

package/dist/lib/jobs/job-runner.d.ts

@@ -11,6 +11,10 @@ export declare class JobRunner {
     constructor();
     private ensureCliAvailable;
     private ensureLogPath;
+    private loadAgentInstructions;
+    private loadMcpConfigs;
+    private writeMcpJson;
+    private cleanupMcpJson;
     private buildInstruction;
     run(job: ScheduledJob, runId: string): Promise<JobRunResult>;
 }

package/dist/lib/jobs/job-runner.js

@@ -18,28 +18,39 @@ function resolveAgent(model) {
         return 'codex';
     return 'claude';
 }
-function buildCommand(agent, instruction, options) {
+function buildCommand(agent, instruction, config) {
     const quotedInstruction = shellQuote(instruction);
+    let mainCommand = '';
     switch (agent) {
         case 'gemini': {
-            const cmd = `gemini --yolo -i ${quotedInstruction}`;
-            return { command: 'gemini', shellCommand: cmd };
+            // For non-Claude agents, use the --mcp flag approach if supported
+            const mcpFlags = config.mcpServers && config.mcpServers.length > 0
+                ? config.mcpServers.map(server => `--mcp ${shellQuote(server)}`).join(' ')
+                : '';
+            mainCommand = `gemini --yolo ${mcpFlags} -i ${quotedInstruction}`;
+            break;
         }
         case 'codex': {
-            const baseCmd = `codex ${quotedInstruction} --dangerously-bypass-approvals-and-sandbox`;
-            const needsPseudoTty = options.runningAsRoot && process.platform !== 'win32';
-            const wrappedCmd = needsPseudoTty
+            // For non-Claude agents, use the --mcp flag approach if supported
+            const mcpFlags = config.mcpServers && config.mcpServers.length > 0
+                ? config.mcpServers.map(server => `--mcp ${shellQuote(server)}`).join(' ')
+                : '';
+            const baseCmd = `codex ${quotedInstruction} --dangerously-bypass-approvals-and-sandbox ${mcpFlags}`.trim();
+            const needsPseudoTty = config.runningAsRoot && process.platform !== 'win32';
+            mainCommand = needsPseudoTty
                 ? `script -q -e -c ${shellQuote(baseCmd)} /dev/null`
                 : baseCmd;
-            return { command: 'codex', shellCommand: wrappedCmd };
+            break;
         }
         case 'claude':
         default: {
-            const prefix = options.runningAsRoot ? 'IS_SANDBOX=1 ' : '';
-            const cmd = `${prefix}claude ${quotedInstruction} --dangerously-skip-permissions`;
-            return { command: 'claude', shellCommand: cmd };
+            // Claude uses .mcp.json for MCP server configuration (no --mcp flag)
+            const prefix = config.runningAsRoot ? 'IS_SANDBOX=1 ' : '';
+            mainCommand = `${prefix}claude ${quotedInstruction} --dangerously-skip-permissions`.trim();
+            break;
         }
     }
+    return { command: agent === 'claude' ? 'claude' : agent, shellCommand: mainCommand };
 }
 const CLI_AGENT_LABEL = {
     claude: 'Claude',
@@ -80,18 +91,103 @@ export class JobRunner {
         await fs.mkdir(logsDir, { recursive: true });
         return path.join(logsDir, `${runId}.log`);
     }
-    buildInstruction(job, agentLabel) {
-        const prompt = job.prompt.trim();
+    async loadAgentInstructions(agentId) {
+        try {
+            const projectRoot = await this.projectRootPromise;
+            const agentPath = path.join(projectRoot, '.nut', 'agents', agentId);
+            const content = await fs.readFile(agentPath, 'utf-8');
+            // Extract content after frontmatter
+            const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+            if (frontmatterMatch && frontmatterMatch[2]) {
+                return frontmatterMatch[2].trim();
+            }
+            return content.trim();
+        }
+        catch (error) {
+            console.warn(`Failed to load agent ${agentId}:`, error);
+            return null;
+        }
+    }
+    async loadMcpConfigs() {
+        try {
+            const projectRoot = await this.projectRootPromise;
+            const mcpConfigPath = path.join(projectRoot, '.nut', 'mcp', 'config.json');
+            const content = await fs.readFile(mcpConfigPath, 'utf-8');
+            const json = JSON.parse(content);
+            return json.mcpServers || {};
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                console.warn('Failed to load MCP config:', error);
+            }
+            return {};
+        }
+    }
+    async writeMcpJson(mcpServers, allMcpConfigs) {
+        const projectRoot = await this.projectRootPromise;
+        const mcpJsonPath = path.join(projectRoot, '.mcp.json');
+        // Filter to only include the requested servers that are enabled
+        const filteredConfigs = {};
+        for (const serverName of mcpServers) {
+            const config = allMcpConfigs[serverName];
+            if (config && config.enabled !== false) {
+                filteredConfigs[serverName] = config;
+            }
+        }
+        const mcpJson = {
+            mcpServers: filteredConfigs
+        };
+        await fs.writeFile(mcpJsonPath, JSON.stringify(mcpJson, null, 2), 'utf-8');
+    }
+    async cleanupMcpJson() {
+        try {
+            const projectRoot = await this.projectRootPromise;
+            const mcpJsonPath = path.join(projectRoot, '.mcp.json');
+            // Reset to empty mcpServers object
+            const emptyMcpJson = {
+                mcpServers: {}
+            };
+            await fs.writeFile(mcpJsonPath, JSON.stringify(emptyMcpJson, null, 2), 'utf-8');
+        }
+        catch (error) {
+            // Don't fail the job if cleanup fails
+            console.warn('Failed to cleanup .mcp.json:', error);
+        }
+    }
+    async buildInstruction(job, agentLabel) {
         const scheduleDescription = job.schedule.type === 'cron'
             ? `Cron: ${job.schedule.expression}`
             : `Interval: every ${job.schedule.hours}h on ${job.schedule.daysOfWeek.join(', ')}`;
-        return `Run this scheduled Coconut job (${job.id}).\nSchedule: ${scheduleDescription}.\nPreferred CLI agent: ${agentLabel}.\nInstruction:\n${prompt}`;
+        let instruction = `Run this scheduled Coconut job (${job.id}).\nSchedule: ${scheduleDescription}.\nPreferred CLI agent: ${agentLabel}.\n\n`;
+        // If an agent is specified, load and use its instructions
+        if (job.agentId) {
+            const agentInstructions = await this.loadAgentInstructions(job.agentId);
+            if (agentInstructions) {
+                instruction += `Agent Instructions (${job.agentId}):\n${agentInstructions}\n\n`;
+            }
+        }
+        // Add custom instructions (or main prompt if no agent)
+        const customInstructions = job.prompt.trim();
+        if (customInstructions) {
+            const label = job.agentId ? 'Additional Custom Instructions' : 'Instructions';
+            instruction += `${label}:\n${customInstructions}`;
+        }
+        return instruction;
     }
     async run(job, runId) {
         const agent = resolveAgent(job.model);
-        const instruction = this.buildInstruction(job, CLI_AGENT_LABEL[agent] || agent);
+        const instruction = await this.buildInstruction(job, CLI_AGENT_LABEL[agent] || agent);
         const runningAsRoot = typeof process.getuid === 'function' && process.getuid() === 0;
-        const { shellCommand } = buildCommand(agent, instruction, { runningAsRoot });
+        // Write .mcp.json if MCP servers are specified (Claude reads this from project root)
+        const mcpJsonWritten = job.mcpServers && job.mcpServers.length > 0 && agent === 'claude';
+        if (mcpJsonWritten) {
+            const allMcpConfigs = await this.loadMcpConfigs();
+            await this.writeMcpJson(job.mcpServers, allMcpConfigs);
+        }
+        const { shellCommand } = buildCommand(agent, instruction, {
+            runningAsRoot,
+            mcpServers: job.mcpServers
+        });
         const projectRoot = await this.projectRootPromise;
         const logPath = await this.ensureLogPath(job.id, runId);
         const logStream = createWriteStream(logPath, { flags: 'a' });
@@ -99,6 +195,9 @@ export class JobRunner {
         logStream.write(`[${new Date().toISOString()}] Starting job ${job.id} using ${agent} CLI\n`);
         logStream.write(`Instruction: ${instruction}\n`);
         logStream.write(`Command: ${shellCommand}\n`);
+        if (job.mcpServers && job.mcpServers.length > 0) {
+            logStream.write(`MCP Servers: ${job.mcpServers.join(', ')} (configured via .mcp.json)\n`);
+        }
         return new Promise((resolve) => {
             let cliMissingError = null;
             try {
@@ -111,6 +210,10 @@ export class JobRunner {
                 const message = cliMissingError.message;
                 logStream.write(`${message}\n`);
                 logStream.end();
+                // Cleanup .mcp.json if it was written
+                if (mcpJsonWritten) {
+                    this.cleanupMcpJson().catch(err => console.warn('Cleanup failed:', err));
+                }
                 resolve({
                     status: 'failed',
                     error: message,
@@ -146,6 +249,10 @@ export class JobRunner {
                 logStream.write(`${message}\n`);
                 logStream.end();
                 clearTimeout(abortTimeout);
+                // Cleanup .mcp.json if it was written
+                if (mcpJsonWritten) {
+                    this.cleanupMcpJson().catch(err => console.warn('Cleanup failed:', err));
+                }
                 resolve({
                     status: 'failed',
                     error: message,
@@ -159,6 +266,10 @@ export class JobRunner {
                 logStream.write(`\n[${new Date().toISOString()}] Job ${job.id} completed with exit code ${code}\n`);
                 logStream.end();
                 clearTimeout(abortTimeout);
+                // Cleanup .mcp.json if it was written
+                if (mcpJsonWritten) {
+                    this.cleanupMcpJson().catch(err => console.warn('Cleanup failed:', err));
+                }
                 const summary = summaryChunks.join('');
                 resolve({
                     status,

package/dist/lib/jobs/job-store.js

@@ -175,6 +175,9 @@ export class JobStore {
             runs,
             tags: data.tags ?? [],
             contextPaths: data.contextPaths ?? [],
+            agentId: data.agentId,
+            agentIds: data.agentIds,
+            mcpServers: data.mcpServers,
         };
     }
     toFrontmatter(job) {
@@ -206,6 +209,9 @@ export class JobStore {
             })),
             tags: job.tags ?? [],
             contextPaths: job.contextPaths ?? [],
+            agentId: job.agentId,
+            agentIds: job.agentIds,
+            mcpServers: job.mcpServers,
         };
     }
 }

package/dist/lib/user-preferences.d.ts

@@ -1,8 +1,10 @@
+import type { AgentRoleId } from '@lovelybunch/types';
 export interface UserProfile {
     firstName?: string;
     lastName?: string;
     email?: string;
-    role?: 'developer' | 'designer' | 'product-manager' | 'other';
+    role?: AgentRoleId;
+    roleDescription?: string;
 }
 export interface UserPreferences {
     theme?: 'light' | 'dark' | 'coconut' | 'system';

package/dist/routes/api/v1/config/route.d.ts

@@ -16,7 +16,7 @@ export declare function PUT(c: Context): Promise<(Response & import("hono").Type
     error: string;
 }, 500, "json">) | (Response & import("hono").TypedResponse<{
     error: string;
-}, 405, "json">)>;
+}, 404, "json">)>;
 export declare function TEST(c: Context): Promise<(Response & import("hono").TypedResponse<{
     success: false;
     message: string;

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

@@ -124,7 +124,51 @@ export async function PUT(c) {
         }
     }
     else {
-        return c.json({ error: 'PUT not supported for project config' }, 405);
+        // Update project config (coconut object)
+        try {
+            const body = await c.req.json();
+            const { coconut } = body;
+            if (!coconut) {
+                return c.json({ error: 'Missing coconut object in request body' }, 400);
+            }
+            const configPath = await getConfigPath();
+            if (!configPath) {
+                return c.json({ error: 'GAIT directory not found' }, 404);
+            }
+            // Load existing config
+            let config = {};
+            try {
+                const content = await fs.readFile(configPath, 'utf-8');
+                config = JSON.parse(content);
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    config = {};
+                }
+                else {
+                    throw error;
+                }
+            }
+            // Ensure .nut directory exists
+            const configDir = path.dirname(configPath);
+            await fs.mkdir(configDir, { recursive: true });
+            // Merge coconut object with existing config
+            config.coconut = {
+                ...config.coconut,
+                ...coconut,
+            };
+            // Save config
+            await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+            return c.json({
+                success: true,
+                message: 'Project configuration updated successfully',
+                data: config
+            });
+        }
+        catch (error) {
+            console.error('Error updating project config:', error);
+            return c.json({ error: 'Failed to update project config' }, 500);
+        }
     }
 }
 // POST /api/v1/config/test

package/dist/routes/api/v1/context/knowledge/[filename]/route.js

@@ -59,14 +59,16 @@ app.get('/:filename', async (c) => {
         const filePath = path.join(knowledgePath, actualFilename);
         const fileContent = await fs.readFile(filePath, 'utf-8');
         const { data, content } = matter(fileContent);
-        // Extract title from first heading or use filename
-        const title = content.match(/^#\s+(.+)$/m)?.[1] ||
+        // Extract title from metadata, first heading, or use filename
+        const title = data.title ||
+            content.match(/^#\s+(.+)$/m)?.[1] ||
             actualFilename.replace('.md', '').replace(/[_-]/g, ' ').replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase());
         const document = {
             filename: actualFilename,
             metadata: {
                 ...data,
-                updated: data.updated || new Date().toISOString().split('T')[0],
+                title, // Include title in metadata
+                updated: data.updated || new Date().toISOString(),
                 tags: data.tags || [],
                 sources: data.sources || []
             },
@@ -107,11 +109,19 @@ app.put('/:filename', async (c) => {
         // Read current content
         const currentContent = await fs.readFile(filePath, 'utf-8');
         const { data: currentData, content: currentMarkdown } = matter(currentContent);
+        // Extract current title from markdown content or metadata
+        const currentTitle = currentMarkdown.match(/^#\s+(.+)$/m)?.[1] ||
+            currentData.title ||
+            actualFilename.replace('.md', '').replace(/[_-]/g, ' ').replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase());
         // Prepare updated content
         const updatedContent = body.content !== undefined ? body.content : currentMarkdown;
+        // Determine if title has changed
+        const newTitle = body.title !== undefined ? body.title : currentTitle;
+        const titleChanged = body.title !== undefined && body.title !== currentTitle;
         const updatedMetadata = {
             ...currentData,
             ...body.metadata,
+            title: newTitle, // Store title in metadata
             updated: new Date().toISOString(),
             // Ensure these are arrays
             tags: body.metadata?.tags !== undefined ? body.metadata.tags : (currentData.tags || []),
@@ -120,8 +130,9 @@ app.put('/:filename', async (c) => {
         // Handle title change - might need to rename file
         let newFilename = actualFilename;
         let newFilePath = filePath;
-        if (body.title) {
-            newFilename = generateFilename(body.title);
+        // Only rename file if title explicitly changed
+        if (titleChanged) {
+            newFilename = generateFilename(newTitle);
             newFilePath = path.join(knowledgePath, newFilename);
             // Check if new filename conflicts with existing file (unless it's the same file)
             if (newFilename !== actualFilename) {
@@ -142,10 +153,6 @@ app.put('/:filename', async (c) => {
         if (newFilename !== actualFilename) {
             await fs.unlink(filePath);
         }
-        // Extract updated title
-        const title = body.title ||
-            updatedContent.match(/^#\s+(.+)$/m)?.[1] ||
-            newFilename.replace('.md', '').replace(/[_-]/g, ' ').replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase());
         // Log knowledge update event
         try {
             const session = await requireAuth(c);
@@ -159,7 +166,7 @@ app.put('/:filename', async (c) => {
                 payload: {
                     filename: newFilename,
                     oldFilename: actualFilename !== newFilename ? actualFilename : undefined,
-                    title,
+                    title: newTitle,
                     category: updatedMetadata.category,
                     summary: generateSummary(updatedContent),
                 }
@@ -172,7 +179,7 @@ app.put('/:filename', async (c) => {
             success: true,
             document: {
                 filename: newFilename,
-                title,
+                title: newTitle,
                 metadata: updatedMetadata,
                 content: updatedContent
             }

package/dist/routes/api/v1/context/knowledge/route.js

@@ -64,13 +64,15 @@ app.get('/', async (c) => {
             const filePath = path.join(knowledgePath, file);
             const fileContent = await fs.readFile(filePath, 'utf-8');
             const { data, content } = matter(fileContent);
-            // Extract title from first heading or use filename
-            const title = content.match(/^#\s+(.+)$/m)?.[1] ||
+            // Extract title from metadata, first heading, or use filename
+            const title = data.title ||
+                content.match(/^#\s+(.+)$/m)?.[1] ||
                 file.replace('.md', '').replace(/[_-]/g, ' ').replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase());
             return {
                 filename: file,
                 metadata: {
                     ...data,
+                    title, // Include title in metadata
                     updated: data.updated || new Date().toISOString(),
                     tags: data.tags || [],
                     sources: data.sources || []
@@ -119,6 +121,7 @@ app.post('/', async (c) => {
         const now = new Date();
         const frontmatter = {
             version: '1.0',
+            title: body.title, // Store title in metadata
             updated: now.toISOString(),
             type: 'knowledge',
             category: body.metadata?.category || 'general',