@lovelybunch/api 1.0.76-alpha.8 → 1.0.76

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

@@ -0,0 +1,159 @@
+import { Hono } from 'hono';
+import { promises as fs } from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+import { findGaitDirectory } from '../../../../../lib/gait-path.js';
+import { getLogger, ContextKinds } from '@lovelybunch/core/logging';
+import { requireAuth } from '../../../../../middleware/auth.js';
+function generateSummary(content, maxLines = 3, maxChars = 200) {
+    const cleanContent = content
+        .replace(/^#+\s+/gm, '')
+        .replace(/[*_`]/g, '')
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+        .trim();
+    const lines = cleanContent.split('\n').filter(line => line.trim().length > 0);
+    const summary = lines.slice(0, maxLines).join(' ');
+    return summary.length > maxChars
+        ? summary.substring(0, maxChars) + '...'
+        : summary;
+}
+const app = new Hono();
+async function getAgentsPath() {
+    const gaitDir = await findGaitDirectory();
+    if (!gaitDir)
+        return null;
+    return path.join(gaitDir, 'context');
+}
+/**
+ * GET /api/v1/context/agents
+ */
+app.get('/', async (c) => {
+    try {
+        const agentsPath = await getAgentsPath();
+        if (!agentsPath) {
+            return c.json({ success: false, error: 'GAIT directory not found' }, 404);
+        }
+        await fs.mkdir(agentsPath, { recursive: true });
+        const filePath = path.join(agentsPath, 'agents.md');
+        try {
+            const fileContent = await fs.readFile(filePath, 'utf-8');
+            const { data, content } = matter(fileContent);
+            const title = content.match(/^#\s+(.+)$/m)?.[1] || 'Agents';
+            const document = {
+                filename: 'agents.md',
+                metadata: {
+                    ...data,
+                    updated: data.updated || new Date().toISOString().split('T')[0],
+                    type: 'agents',
+                    category: 'context',
+                    tags: data.tags || []
+                },
+                content,
+                title
+            };
+            return c.json({ success: true, document });
+        }
+        catch (fileError) {
+            const defaultContent = `# Agents
+
+This document defines the agents available in this project.
+
+## Agent Definitions
+
+Describe agents, their capabilities, and configurations.
+
+## Agent Guidelines
+
+Key guidelines for agent behavior and interaction patterns.
+`;
+            const document = {
+                filename: 'agents.md',
+                metadata: {
+                    version: '1.0',
+                    updated: new Date().toISOString().split('T')[0],
+                    type: 'agents',
+                    category: 'context',
+                    tags: []
+                },
+                content: defaultContent,
+                title: 'Agents'
+            };
+            return c.json({ success: true, document });
+        }
+    }
+    catch (error) {
+        console.error('Error loading agents document:', error);
+        return c.json({ success: false, error: 'Failed to load agents document' }, 500);
+    }
+});
+/**
+ * PUT /api/v1/context/agents
+ */
+app.put('/', async (c) => {
+    try {
+        const body = await c.req.json();
+        if (!body.content) {
+            return c.json({ success: false, error: 'Content is required' }, 400);
+        }
+        const agentsPath = await getAgentsPath();
+        if (!agentsPath) {
+            return c.json({ success: false, error: 'GAIT directory not found' }, 404);
+        }
+        await fs.mkdir(agentsPath, { recursive: true });
+        const filePath = path.join(agentsPath, 'agents.md');
+        let currentData = {};
+        try {
+            const currentContent = await fs.readFile(filePath, 'utf-8');
+            const { data } = matter(currentContent);
+            currentData = data;
+        }
+        catch {
+            // File doesn't exist, use defaults
+        }
+        const updatedMetadata = {
+            ...currentData,
+            ...body.metadata,
+            updated: new Date().toISOString().split('T')[0],
+            type: 'agents',
+            category: 'context',
+            version: currentData.version || '1.0'
+        };
+        const fileContent = matter.stringify(body.content, updatedMetadata);
+        await fs.writeFile(filePath, fileContent, 'utf-8');
+        const title = body.title ||
+            body.content.match(/^#\s+(.+)$/m)?.[1] ||
+            'Agents';
+        try {
+            const session = await requireAuth(c);
+            const actor = session ? `human:${session.email}` : "human:unknown";
+            const logger = getLogger();
+            logger.log({
+                kind: ContextKinds.AGENTS_UPDATE,
+                actor,
+                subject: `context:agents.md`,
+                tags: ["context", "agents"],
+                payload: {
+                    title,
+                    summary: generateSummary(body.content),
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging agents update:', logError);
+        }
+        return c.json({
+            success: true,
+            document: {
+                filename: 'agents.md',
+                title,
+                metadata: updatedMetadata,
+                content: body.content
+            }
+        });
+    }
+    catch (error) {
+        console.error('Error updating agents document:', error);
+        return c.json({ success: false, error: 'Failed to update agents document' }, 500);
+    }
+});
+export default app;

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

@@ -1,11 +1,13 @@
 import { Hono } from 'hono';
-import project from './project/route.js';
-import architecture from './architecture/route.js';
 import role from './role/route.js';
+import agents from './agents/route.js';
+import team from './team/route.js';
+import memory from './memory/route.js';
 import images from './images/index.js';
 const context = new Hono();
-context.route('/project', project);
-context.route('/architecture', architecture);
 context.route('/role', role);
+context.route('/agents', agents);
+context.route('/team', team);
+context.route('/memory', memory);
 context.route('/images', images);
 export default context;

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

@@ -0,0 +1,163 @@
+import { Hono } from 'hono';
+import { promises as fs } from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+import { findGaitDirectory } from '../../../../../lib/gait-path.js';
+import { getLogger, ContextKinds } from '@lovelybunch/core/logging';
+import { requireAuth } from '../../../../../middleware/auth.js';
+function generateSummary(content, maxLines = 3, maxChars = 200) {
+    const cleanContent = content
+        .replace(/^#+\s+/gm, '')
+        .replace(/[*_`]/g, '')
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+        .trim();
+    const lines = cleanContent.split('\n').filter(line => line.trim().length > 0);
+    const summary = lines.slice(0, maxLines).join(' ');
+    return summary.length > maxChars
+        ? summary.substring(0, maxChars) + '...'
+        : summary;
+}
+const app = new Hono();
+async function getMemoryPath() {
+    const gaitDir = await findGaitDirectory();
+    if (!gaitDir)
+        return null;
+    return path.join(gaitDir, 'context');
+}
+/**
+ * GET /api/v1/context/memory
+ */
+app.get('/', async (c) => {
+    try {
+        const memoryPath = await getMemoryPath();
+        if (!memoryPath) {
+            return c.json({ success: false, error: 'GAIT directory not found' }, 404);
+        }
+        await fs.mkdir(memoryPath, { recursive: true });
+        const filePath = path.join(memoryPath, 'memory.md');
+        try {
+            const fileContent = await fs.readFile(filePath, 'utf-8');
+            const { data, content } = matter(fileContent);
+            const title = content.match(/^#\s+(.+)$/m)?.[1] || 'Memory';
+            const document = {
+                filename: 'memory.md',
+                metadata: {
+                    ...data,
+                    updated: data.updated || new Date().toISOString().split('T')[0],
+                    type: 'memory',
+                    category: 'context',
+                    tags: data.tags || []
+                },
+                content,
+                title
+            };
+            return c.json({ success: true, document });
+        }
+        catch (fileError) {
+            const defaultContent = `# Memory
+
+This document stores persistent memory and learned context.
+
+## Key Decisions
+
+Important decisions made during the project.
+
+## Lessons Learned
+
+Insights and patterns discovered over time.
+
+## Preferences
+
+Remembered preferences and conventions.
+`;
+            const document = {
+                filename: 'memory.md',
+                metadata: {
+                    version: '1.0',
+                    updated: new Date().toISOString().split('T')[0],
+                    type: 'memory',
+                    category: 'context',
+                    tags: []
+                },
+                content: defaultContent,
+                title: 'Memory'
+            };
+            return c.json({ success: true, document });
+        }
+    }
+    catch (error) {
+        console.error('Error loading memory document:', error);
+        return c.json({ success: false, error: 'Failed to load memory document' }, 500);
+    }
+});
+/**
+ * PUT /api/v1/context/memory
+ */
+app.put('/', async (c) => {
+    try {
+        const body = await c.req.json();
+        if (!body.content) {
+            return c.json({ success: false, error: 'Content is required' }, 400);
+        }
+        const memoryPath = await getMemoryPath();
+        if (!memoryPath) {
+            return c.json({ success: false, error: 'GAIT directory not found' }, 404);
+        }
+        await fs.mkdir(memoryPath, { recursive: true });
+        const filePath = path.join(memoryPath, 'memory.md');
+        let currentData = {};
+        try {
+            const currentContent = await fs.readFile(filePath, 'utf-8');
+            const { data } = matter(currentContent);
+            currentData = data;
+        }
+        catch {
+            // File doesn't exist, use defaults
+        }
+        const updatedMetadata = {
+            ...currentData,
+            ...body.metadata,
+            updated: new Date().toISOString().split('T')[0],
+            type: 'memory',
+            category: 'context',
+            version: currentData.version || '1.0'
+        };
+        const fileContent = matter.stringify(body.content, updatedMetadata);
+        await fs.writeFile(filePath, fileContent, 'utf-8');
+        const title = body.title ||
+            body.content.match(/^#\s+(.+)$/m)?.[1] ||
+            'Memory';
+        try {
+            const session = await requireAuth(c);
+            const actor = session ? `human:${session.email}` : "human:unknown";
+            const logger = getLogger();
+            logger.log({
+                kind: ContextKinds.MEMORY_UPDATE,
+                actor,
+                subject: `context:memory.md`,
+                tags: ["context", "memory"],
+                payload: {
+                    title,
+                    summary: generateSummary(body.content),
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging memory update:', logError);
+        }
+        return c.json({
+            success: true,
+            document: {
+                filename: 'memory.md',
+                title,
+                metadata: updatedMetadata,
+                content: body.content
+            }
+        });
+    }
+    catch (error) {
+        console.error('Error updating memory document:', error);
+        return c.json({ success: false, error: 'Failed to update memory document' }, 500);
+    }
+});
+export default app;

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

@@ -0,0 +1,159 @@
+import { Hono } from 'hono';
+import { promises as fs } from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+import { findGaitDirectory } from '../../../../../lib/gait-path.js';
+import { getLogger, ContextKinds } from '@lovelybunch/core/logging';
+import { requireAuth } from '../../../../../middleware/auth.js';
+function generateSummary(content, maxLines = 3, maxChars = 200) {
+    const cleanContent = content
+        .replace(/^#+\s+/gm, '')
+        .replace(/[*_`]/g, '')
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+        .trim();
+    const lines = cleanContent.split('\n').filter(line => line.trim().length > 0);
+    const summary = lines.slice(0, maxLines).join(' ');
+    return summary.length > maxChars
+        ? summary.substring(0, maxChars) + '...'
+        : summary;
+}
+const app = new Hono();
+async function getTeamPath() {
+    const gaitDir = await findGaitDirectory();
+    if (!gaitDir)
+        return null;
+    return path.join(gaitDir, 'context');
+}
+/**
+ * GET /api/v1/context/team
+ */
+app.get('/', async (c) => {
+    try {
+        const teamPath = await getTeamPath();
+        if (!teamPath) {
+            return c.json({ success: false, error: 'GAIT directory not found' }, 404);
+        }
+        await fs.mkdir(teamPath, { recursive: true });
+        const filePath = path.join(teamPath, 'team.md');
+        try {
+            const fileContent = await fs.readFile(filePath, 'utf-8');
+            const { data, content } = matter(fileContent);
+            const title = content.match(/^#\s+(.+)$/m)?.[1] || 'Team';
+            const document = {
+                filename: 'team.md',
+                metadata: {
+                    ...data,
+                    updated: data.updated || new Date().toISOString().split('T')[0],
+                    type: 'team',
+                    category: 'context',
+                    tags: data.tags || []
+                },
+                content,
+                title
+            };
+            return c.json({ success: true, document });
+        }
+        catch (fileError) {
+            const defaultContent = `# Team
+
+This document describes the team structure and members.
+
+## Team Members
+
+List team members, their roles, and responsibilities.
+
+## Communication
+
+Team communication channels and conventions.
+`;
+            const document = {
+                filename: 'team.md',
+                metadata: {
+                    version: '1.0',
+                    updated: new Date().toISOString().split('T')[0],
+                    type: 'team',
+                    category: 'context',
+                    tags: []
+                },
+                content: defaultContent,
+                title: 'Team'
+            };
+            return c.json({ success: true, document });
+        }
+    }
+    catch (error) {
+        console.error('Error loading team document:', error);
+        return c.json({ success: false, error: 'Failed to load team document' }, 500);
+    }
+});
+/**
+ * PUT /api/v1/context/team
+ */
+app.put('/', async (c) => {
+    try {
+        const body = await c.req.json();
+        if (!body.content) {
+            return c.json({ success: false, error: 'Content is required' }, 400);
+        }
+        const teamPath = await getTeamPath();
+        if (!teamPath) {
+            return c.json({ success: false, error: 'GAIT directory not found' }, 404);
+        }
+        await fs.mkdir(teamPath, { recursive: true });
+        const filePath = path.join(teamPath, 'team.md');
+        let currentData = {};
+        try {
+            const currentContent = await fs.readFile(filePath, 'utf-8');
+            const { data } = matter(currentContent);
+            currentData = data;
+        }
+        catch {
+            // File doesn't exist, use defaults
+        }
+        const updatedMetadata = {
+            ...currentData,
+            ...body.metadata,
+            updated: new Date().toISOString().split('T')[0],
+            type: 'team',
+            category: 'context',
+            version: currentData.version || '1.0'
+        };
+        const fileContent = matter.stringify(body.content, updatedMetadata);
+        await fs.writeFile(filePath, fileContent, 'utf-8');
+        const title = body.title ||
+            body.content.match(/^#\s+(.+)$/m)?.[1] ||
+            'Team';
+        try {
+            const session = await requireAuth(c);
+            const actor = session ? `human:${session.email}` : "human:unknown";
+            const logger = getLogger();
+            logger.log({
+                kind: ContextKinds.TEAM_UPDATE,
+                actor,
+                subject: `context:team.md`,
+                tags: ["context", "team"],
+                payload: {
+                    title,
+                    summary: generateSummary(body.content),
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging team update:', logError);
+        }
+        return c.json({
+            success: true,
+            document: {
+                filename: 'team.md',
+                title,
+                metadata: updatedMetadata,
+                content: body.content
+            }
+        });
+    }
+    catch (error) {
+        console.error('Error updating team document:', error);
+        return c.json({ success: false, error: 'Failed to update team document' }, 500);
+    }
+});
+export default app;

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

@@ -1,6 +1,7 @@
 import { Hono } from 'hono';
 import crypto from 'crypto';
-import { getRepoStatus, listBranches, createBranch, deleteBranch, switchBranch, mergeBranch, pushCurrent, pullCurrent, listWorktrees, addWorktree, removeWorktree, commitInWorktree, pushWorktree, pullWorktree, checkRemoteAuth, getCredentialConfig, storeCredentials, getCommitDetails, getFileDiff, setRemoteUrl, } from '../../../../lib/git.js';
+import { getRepoStatus, listBranches, createBranch, deleteBranch, switchBranch, mergeBranch, pushCurrent, pullCurrent, listWorktrees, addWorktree, removeWorktree, commitInWorktree, pushWorktree, pullWorktree, checkRemoteAuth, getCredentialConfig, storeCredentials, getCommitDetails, getFileDiff, setRemoteUrl, lsTree, getInstructionFiles, } from '../../../../lib/git.js';
+import { INSTRUCTION_FILE_KINDS } from '@lovelybunch/types';
 import { saveGithubToken, clearGithubToken, readGithubToken, isGithubTokenValid } from '../../../../lib/github-token.js';
 import { createGithubAuthState, consumeGithubAuthState } from '../../../../lib/github-auth-state.js';
 import { resolveCoconutId, resolveControlPlaneUrl } from '../../../../lib/coconut-context.js';
@@ -674,4 +675,29 @@ app.get('/commits/:sha/files/:filepath{.+}', async (c) => {
         return c.json({ success: false, error: { message: e.message || 'Failed to get file diff' } }, 500);
     }
 });
+// ls-tree
+app.get('/ls-tree', async (c) => {
+    try {
+        const files = await lsTree();
+        return c.json({ success: true, data: files });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message || 'Failed to list tree' } }, 500);
+    }
+});
+// instruction-files
+const VALID_FILTERS = new Set([...INSTRUCTION_FILE_KINDS, 'all']);
+app.get('/instruction-files', async (c) => {
+    try {
+        const kind = (c.req.query('kind') || 'all');
+        if (!VALID_FILTERS.has(kind)) {
+            return c.json({ success: false, error: { message: `Invalid kind. Must be one of: ${[...VALID_FILTERS].join(', ')}` } }, 400);
+        }
+        const data = await getInstructionFiles(kind);
+        return c.json({ success: true, data });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message || 'Failed to retrieve instruction files' } }, 500);
+    }
+});
 export default app;

package/dist/routes/api/v1/jobs/[id]/route.d.ts

@@ -9,12 +9,6 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
 }, 404, "json">) | (Response & import("hono").TypedResponse<{
     success: true;
     data: {
-        id: string;
-        name: string;
-        description?: string;
-        prompt: string;
-        model: string;
-        status: ScheduledJobStatus;
         schedule: {
             type: "cron";
             expression: string;
@@ -27,29 +21,32 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
             timezone?: string;
             anchorHour?: number;
         };
+        description?: string;
+        id: string;
+        name: string;
+        prompt: string;
+        model: string;
+        status: ScheduledJobStatus;
         metadata: {
             createdAt: string;
             updatedAt: string;
             lastRunAt?: string;
             nextRunAt?: string;
         };
+        tags?: string[];
+        contextPaths?: string[];
+        agentId?: string;
+        agentIds?: string[];
+        mcpServers?: string[];
         runs: {
+            error?: string;
             id: string;
+            status: import("@lovelybunch/types").ScheduledJobRunStatus;
             jobId: string;
             trigger: import("@lovelybunch/types").ScheduledJobTrigger;
-            status: import("@lovelybunch/types").ScheduledJobRunStatus;
             startedAt: string;
             finishedAt?: string;
-            outputPath?: string;
-            summary?: string;
-            error?: string;
-            cliCommand?: string;
         }[];
-        tags?: string[];
-        contextPaths?: string[];
-        agentId?: string;
-        agentIds?: string[];
-        mcpServers?: string[];
     };
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     success: false;
@@ -73,12 +70,6 @@ export declare function PATCH(c: Context): Promise<(Response & import("hono").Ty
 }, 400, "json">) | (Response & import("hono").TypedResponse<{
     success: true;
     data: {
-        id: string;
-        name: string;
-        description?: string;
-        prompt: string;
-        model: string;
-        status: ScheduledJobStatus;
         schedule: {
             type: "cron";
             expression: string;
@@ -91,29 +82,32 @@ export declare function PATCH(c: Context): Promise<(Response & import("hono").Ty
             timezone?: string;
             anchorHour?: number;
         };
+        description?: string;
+        id: string;
+        name: string;
+        prompt: string;
+        model: string;
+        status: ScheduledJobStatus;
         metadata: {
             createdAt: string;
             updatedAt: string;
             lastRunAt?: string;
             nextRunAt?: string;
         };
+        tags?: string[];
+        contextPaths?: string[];
+        agentId?: string;
+        agentIds?: string[];
+        mcpServers?: string[];
         runs: {
+            error?: string;
             id: string;
+            status: import("@lovelybunch/types").ScheduledJobRunStatus;
             jobId: string;
             trigger: import("@lovelybunch/types").ScheduledJobTrigger;
-            status: import("@lovelybunch/types").ScheduledJobRunStatus;
             startedAt: string;
             finishedAt?: string;
-            outputPath?: string;
-            summary?: string;
-            error?: string;
-            cliCommand?: string;
         }[];
-        tags?: string[];
-        contextPaths?: string[];
-        agentId?: string;
-        agentIds?: string[];
-        mcpServers?: string[];
     };
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     success: false;

package/dist/routes/api/v1/jobs/[id]/route.js

@@ -1,6 +1,6 @@
 import { JobStore } from '../../../../../lib/jobs/job-store.js';
 import { getGlobalJobScheduler } from '../../../../../lib/jobs/global-job-scheduler.js';
-import { normalizeSchedule, normalizeStatus, } from '../route.js';
+import { normalizeSchedule, normalizeStatus, withLightweightRuns, } from '../route.js';
 const store = new JobStore();
 const scheduler = getGlobalJobScheduler();
 function normalizeScheduleUpdate(current, incoming) {
@@ -32,7 +32,7 @@ export async function GET(c) {
                 }
             }, 404);
         }
-        return c.json({ success: true, data: job });
+        return c.json({ success: true, data: withLightweightRuns(job) });
     }
     catch (error) {
         console.error('Failed to fetch job:', error);
@@ -101,7 +101,7 @@ export async function PATCH(c) {
         const reloaded = await store.getJob(updated.id);
         return c.json({
             success: true,
-            data: reloaded ?? updated
+            data: withLightweightRuns(reloaded ?? updated)
         });
     }
     catch (error) {