@lovelybunch/api 1.0.68 → 1.0.69-alpha.0

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

@@ -1,6 +1,7 @@
 import { randomUUID } from 'crypto';
 import { JobStore } from './job-store.js';
 import { JobRunner } from './job-runner.js';
+import { getLogger, JobKinds } from '@lovelybunch/core/logging';
 const DAY_TO_INDEX = {
     sunday: 0,
     monday: 1,
@@ -38,6 +39,28 @@ export class JobScheduler {
         }
         const nextRun = this.calculateNextRun(job);
         await this.updateJobMetadata(job, nextRun);
+        // Log job scheduling
+        try {
+            const logger = getLogger();
+            const interval = job.schedule.type === 'cron'
+                ? `cron: ${job.schedule.expression}`
+                : `interval: ${job.schedule.hours}h on ${job.schedule.daysOfWeek.join(', ')}`;
+            logger.log({
+                kind: JobKinds.SCHEDULE,
+                actor: `system`,
+                subject: `job:${job.id}`,
+                tags: ["job", "schedule"],
+                payload: {
+                    jobId: job.id,
+                    agentName: job.model || 'claude',
+                    interval,
+                    nextRun: nextRun?.toISOString(),
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging job schedule:', logError);
+        }
         if (!nextRun) {
             console.warn(`No upcoming execution found for job ${job.id}`);
             return;
@@ -109,6 +132,26 @@ export class JobScheduler {
         job.metadata.lastRunAt = start;
         job.metadata.updatedAt = new Date();
         await this.store.saveJob(job);
+        // Log job run start
+        try {
+            const logger = getLogger();
+            logger.log({
+                kind: JobKinds.RUN_START,
+                actor: `agent:${job.model || 'claude'}`,
+                subject: `job:${job.id}`,
+                trace: runId,
+                tags: ["job", "run"],
+                payload: {
+                    jobId: job.id,
+                    runId,
+                    agentName: job.model || 'claude',
+                    trigger,
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging job run start:', logError);
+        }
         let outcome = null;
         try {
             const result = await this.runner.run(job, runId);
@@ -119,6 +162,28 @@ export class JobScheduler {
             runRecord.error = result.error;
             runRecord.cliCommand = result.cliCommand;
             outcome = { ...runRecord };
+            // Log job run end
+            try {
+                const logger = getLogger();
+                const duration = runRecord.finishedAt.getTime() - start.getTime();
+                logger.log({
+                    kind: JobKinds.RUN_END,
+                    actor: `agent:${job.model || 'claude'}`,
+                    subject: `job:${job.id}`,
+                    trace: runId,
+                    tags: ["job", "run"],
+                    payload: {
+                        jobId: job.id,
+                        runId,
+                        status: result.status,
+                        duration,
+                        logPath: result.outputPath,
+                    }
+                });
+            }
+            catch (logError) {
+                console.error('Error logging job run end:', logError);
+            }
         }
         catch (error) {
             runRecord.status = 'failed';
@@ -126,6 +191,27 @@ export class JobScheduler {
             runRecord.error = error?.message || 'Unknown error executing scheduled job';
             runRecord.summary = runRecord.error;
             outcome = { ...runRecord };
+            // Log job run error
+            try {
+                const logger = getLogger();
+                logger.log({
+                    kind: JobKinds.RUN_ERROR,
+                    actor: `agent:${job.model || 'claude'}`,
+                    subject: `job:${job.id}`,
+                    trace: runId,
+                    level: "error",
+                    tags: ["job", "run", "error"],
+                    payload: {
+                        jobId: job.id,
+                        runId,
+                        error: error?.message || 'Unknown error',
+                        stack: error?.stack,
+                    }
+                });
+            }
+            catch (logError) {
+                console.error('Error logging job run error:', logError);
+            }
         }
         try {
             await this.store.saveJob(job);

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

@@ -4,6 +4,7 @@ import path from 'path';
 import fs from 'fs';
 import { createInitScript } from './context-helper.js';
 import { getShellPath, getShellArgs, prepareShellInit } from './shell-utils.js';
+import { getLogger, AgentKinds } from '@lovelybunch/core/logging';
 export class TerminalManager {
     sessions = new Map();
     cleanupInterval;
@@ -120,6 +121,27 @@ export class TerminalManager {
             previewPingIntervals: new Map(),
         };
         this.sessions.set(sessionId, session);
+        // Log session start
+        try {
+            const logger = getLogger();
+            logger.log({
+                kind: AgentKinds.SESSION_START,
+                actor: `agent:terminal`,
+                subject: `session:${sessionId}`,
+                trace: sessionId,
+                tags: ["agent", "terminal", "session"],
+                payload: {
+                    sessionId,
+                    proposalId,
+                    cwd: projectRoot,
+                    shell: shellPath,
+                }
+            });
+        }
+        catch (error) {
+            // Logging errors should not break session creation
+            console.error('Error logging session start:', error);
+        }
         // Set up PTY event handlers
         ptyProcess.onData((data) => {
             session.lastActivity = new Date();
@@ -155,10 +177,12 @@ export class TerminalManager {
             this.enqueuePreviewBroadcast(session, data);
         });
         ptyProcess.onExit((e) => {
+            const endTime = new Date();
+            const duration = endTime.getTime() - session.createdAt.getTime();
             // Log session end if logging is enabled
             if (session.enableLogging && session.logFilePath) {
                 try {
-                    const timestamp = new Date().toISOString();
+                    const timestamp = endTime.toISOString();
                     const logEntry = `\n[${timestamp}] SESSION ENDED: Exit code ${e.exitCode}\n`;
                     fs.appendFileSync(session.logFilePath, logEntry);
                 }
@@ -166,6 +190,26 @@ export class TerminalManager {
                     console.error('Error writing session end to log:', error);
                 }
             }
+            // Log session end to activity log
+            try {
+                const logger = getLogger();
+                logger.log({
+                    kind: AgentKinds.SESSION_END,
+                    actor: `agent:terminal`,
+                    subject: `session:${sessionId}`,
+                    trace: sessionId,
+                    tags: ["agent", "terminal", "session"],
+                    payload: {
+                        sessionId,
+                        exitCode: e.exitCode,
+                        duration,
+                        signal: e.signal,
+                    }
+                });
+            }
+            catch (error) {
+                console.error('Error logging session end:', error);
+            }
             // Clean up init script, temp directories, and ephemeral files
             try {
                 if (fs.existsSync(initScriptPath)) {

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

@@ -3,6 +3,24 @@ 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';
+// Helper function to generate a simple summary from content
+function generateSummary(content, maxLines = 3, maxChars = 200) {
+    // Remove markdown formatting for cleaner summary
+    const cleanContent = content
+        .replace(/^#+\s+/gm, '') // Remove headings
+        .replace(/[*_`]/g, '') // Remove bold, italic, code
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1') // Convert links to text
+        .trim();
+    // Get first few lines
+    const lines = cleanContent.split('\n').filter(line => line.trim().length > 0);
+    const summary = lines.slice(0, maxLines).join(' ');
+    // Truncate if too long
+    return summary.length > maxChars
+        ? summary.substring(0, maxChars) + '...'
+        : summary;
+}
 const app = new Hono();
 async function getArchitecturePath() {
     const gaitDir = await findGaitDirectory();
@@ -190,6 +208,25 @@ app.put('/', async (c) => {
         const title = body.title ||
             body.content.match(/^#\s+(.+)$/m)?.[1] ||
             'Architecture Overview';
+        // Log architecture update event
+        try {
+            const session = await requireAuth(c);
+            const actor = session ? `human:${session.email}` : "human:unknown";
+            const logger = getLogger();
+            logger.log({
+                kind: ContextKinds.ARCHITECTURE_UPDATE,
+                actor,
+                subject: `context:architecture.md`,
+                tags: ["context", "architecture"],
+                payload: {
+                    title,
+                    summary: generateSummary(body.content),
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging architecture update:', logError);
+        }
         return c.json({
             success: true,
             document: {

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

@@ -2,6 +2,24 @@ import { Hono } from 'hono';
 import { promises as fs } from 'fs';
 import path from 'path';
 import matter from 'gray-matter';
+import { getLogger, KnowledgeKinds } from '@lovelybunch/core/logging';
+import { requireAuth } from '../../../../../../middleware/auth.js';
+// Helper function to generate a simple summary from content
+function generateSummary(content, maxLines = 3, maxChars = 200) {
+    // Remove markdown formatting for cleaner summary
+    const cleanContent = content
+        .replace(/^#+\s+/gm, '') // Remove headings
+        .replace(/[*_`]/g, '') // Remove bold, italic, code
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1') // Convert links to text
+        .trim();
+    // Get first few lines
+    const lines = cleanContent.split('\n').filter(line => line.trim().length > 0);
+    const summary = lines.slice(0, maxLines).join(' ');
+    // Truncate if too long
+    return summary.length > maxChars
+        ? summary.substring(0, maxChars) + '...'
+        : summary;
+}
 const app = new Hono();
 function getKnowledgePath() {
     let basePath;
@@ -128,6 +146,28 @@ app.put('/:filename', async (c) => {
         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);
+            const actor = session ? `human:${session.email}` : "human:unknown";
+            const logger = getLogger();
+            logger.log({
+                kind: KnowledgeKinds.UPDATE,
+                actor,
+                subject: `knowledge:${newFilename}`,
+                tags: ["knowledge", ...(updatedMetadata.tags || [])],
+                payload: {
+                    filename: newFilename,
+                    oldFilename: actualFilename !== newFilename ? actualFilename : undefined,
+                    title,
+                    category: updatedMetadata.category,
+                    summary: generateSummary(updatedContent),
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging knowledge update:', logError);
+        }
         return c.json({
             success: true,
             document: {
@@ -160,8 +200,37 @@ app.delete('/:filename', async (c) => {
         catch {
             return c.json({ success: false, error: 'Knowledge document not found' }, 404);
         }
+        // Read file before deletion for logging
+        let title;
+        try {
+            const fileContent = await fs.readFile(filePath, 'utf-8');
+            const { content } = matter(fileContent);
+            title = content.match(/^#\s+(.+)$/m)?.[1];
+        }
+        catch {
+            // Ignore if we can't read the file
+        }
         // Delete the file
         await fs.unlink(filePath);
+        // Log knowledge deletion event
+        try {
+            const session = await requireAuth(c);
+            const actor = session ? `human:${session.email}` : "human:unknown";
+            const logger = getLogger();
+            logger.log({
+                kind: KnowledgeKinds.DELETE,
+                actor,
+                subject: `knowledge:${actualFilename}`,
+                tags: ["knowledge"],
+                payload: {
+                    filename: actualFilename,
+                    title,
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging knowledge deletion:', logError);
+        }
         return c.json({
             success: true,
             message: 'Knowledge document deleted successfully'

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

@@ -3,6 +3,24 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import matter from 'gray-matter';
 import filenameRoute from './[filename]/index.js';
+import { getLogger, KnowledgeKinds } from '@lovelybunch/core/logging';
+import { requireAuth } from '../../../../../middleware/auth.js';
+// Helper function to generate a simple summary from content
+function generateSummary(content, maxLines = 3, maxChars = 200) {
+    // Remove markdown formatting for cleaner summary
+    const cleanContent = content
+        .replace(/^#+\s+/gm, '') // Remove headings
+        .replace(/[*_`]/g, '') // Remove bold, italic, code
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1') // Convert links to text
+        .trim();
+    // Get first few lines
+    const lines = cleanContent.split('\n').filter(line => line.trim().length > 0);
+    const summary = lines.slice(0, maxLines).join(' ');
+    // Truncate if too long
+    return summary.length > maxChars
+        ? summary.substring(0, maxChars) + '...'
+        : summary;
+}
 const app = new Hono();
 function getKnowledgePath() {
     let basePath;
@@ -111,6 +129,27 @@ app.post('/', async (c) => {
         // Create the markdown content with frontmatter
         const fileContent = matter.stringify(body.content, frontmatter);
         await fs.writeFile(filePath, fileContent, 'utf-8');
+        // Log knowledge creation event
+        try {
+            const session = await requireAuth(c);
+            const actor = session ? `human:${session.email}` : "human:unknown";
+            const logger = getLogger();
+            logger.log({
+                kind: KnowledgeKinds.CREATE,
+                actor,
+                subject: `knowledge:${filename}`,
+                tags: ["knowledge", ...(frontmatter.tags || [])],
+                payload: {
+                    filename,
+                    title: body.title,
+                    category: frontmatter.category,
+                    summary: generateSummary(body.content),
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging knowledge creation:', logError);
+        }
         return c.json({
             success: true,
             document: {

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

@@ -3,6 +3,24 @@ 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';
+// Helper function to generate a simple summary from content
+function generateSummary(content, maxLines = 3, maxChars = 200) {
+    // Remove markdown formatting for cleaner summary
+    const cleanContent = content
+        .replace(/^#+\s+/gm, '') // Remove headings
+        .replace(/[*_`]/g, '') // Remove bold, italic, code
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1') // Convert links to text
+        .trim();
+    // Get first few lines
+    const lines = cleanContent.split('\n').filter(line => line.trim().length > 0);
+    const summary = lines.slice(0, maxLines).join(' ');
+    // Truncate if too long
+    return summary.length > maxChars
+        ? summary.substring(0, maxChars) + '...'
+        : summary;
+}
 const app = new Hono();
 async function getProjectPath() {
     const gaitDir = await findGaitDirectory();
@@ -145,6 +163,25 @@ app.put('/', async (c) => {
         const title = body.title ||
             body.content.match(/^#\s+(.+)$/m)?.[1] ||
             'Project Overview';
+        // Log project update event
+        try {
+            const session = await requireAuth(c);
+            const actor = session ? `human:${session.email}` : "human:unknown";
+            const logger = getLogger();
+            logger.log({
+                kind: ContextKinds.PROJECT_UPDATE,
+                actor,
+                subject: `context:project.md`,
+                tags: ["context", "project"],
+                payload: {
+                    title,
+                    summary: generateSummary(body.content),
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging project update:', logError);
+        }
         return c.json({
             success: true,
             document: {

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

@@ -5,6 +5,8 @@ import { saveGithubToken, clearGithubToken } from '../../../../lib/github-token.
 import { createGithubAuthState, consumeGithubAuthState } from '../../../../lib/github-auth-state.js';
 import { resolveCoconutId, resolveControlPlaneUrl } from '../../../../lib/coconut-context.js';
 import { loadGitSettings, saveGitSettings, isGitAuthMode } from '../../../../lib/git-settings.js';
+import { getLogger, CodeKinds } from '@lovelybunch/core/logging';
+import { requireAuth } from '../../../../middleware/auth.js';
 const app = new Hono();
 // Settings
 app.get('/settings', async (c) => {
@@ -201,6 +203,25 @@ app.post('/branches', async (c) => {
         if (!name)
             return c.json({ success: false, error: { message: 'name required' } }, 400);
         await createBranch(name, from);
+        // Log branch creation
+        try {
+            const session = await requireAuth(c);
+            const actor = session ? `human:${session.email}` : "human:unknown";
+            const logger = getLogger();
+            logger.log({
+                kind: CodeKinds.BRANCH_CREATE,
+                actor,
+                subject: `branch:${name}`,
+                tags: ["git", "branch"],
+                payload: {
+                    branch: name,
+                    baseBranch: from,
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging branch creation:', logError);
+        }
         return c.json({ success: true, data: { created: name, from } });
     }
     catch (e) {
@@ -211,6 +232,24 @@ app.delete('/branches/:branch', async (c) => {
     try {
         const name = c.req.param('branch');
         await deleteBranch(name);
+        // Log branch deletion
+        try {
+            const session = await requireAuth(c);
+            const actor = session ? `human:${session.email}` : "human:unknown";
+            const logger = getLogger();
+            logger.log({
+                kind: CodeKinds.BRANCH_DELETE,
+                actor,
+                subject: `branch:${name}`,
+                tags: ["git", "branch"],
+                payload: {
+                    branch: name,
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging branch deletion:', logError);
+        }
         return c.json({ success: true, data: { deleted: name } });
     }
     catch (e) {
@@ -262,8 +301,40 @@ app.post('/commits', async (c) => {
             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() } });
+        const { stdout: commitSha } = await runGit(['rev-parse', 'HEAD']);
+        const sha = commitSha.trim();
+        // Get current branch
+        const { stdout: branchOutput } = await runGit(['branch', '--show-current']);
+        const currentBranch = branchOutput.trim();
+        // Get commit stats
+        const { stdout: statsOutput } = await runGit(['show', '--stat', '--format=', sha]);
+        const filesChanged = (statsOutput.match(/\d+ files? changed/)?.[0] || '0 files changed').split(' ')[0];
+        const insertions = (statsOutput.match(/(\d+) insertions?\(\+\)/)?.[1] || '0');
+        const deletions = (statsOutput.match(/(\d+) deletions?\(-\)/)?.[1] || '0');
+        // Log commit event
+        try {
+            const session = await requireAuth(c);
+            const actor = session ? `human:${session.email}` : "human:unknown";
+            const logger = getLogger();
+            logger.log({
+                kind: CodeKinds.COMMIT,
+                actor,
+                subject: `commit:${sha}`,
+                tags: ["git", "commit"],
+                payload: {
+                    sha,
+                    branch: currentBranch,
+                    message,
+                    filesChanged: parseInt(filesChanged),
+                    insertions: parseInt(insertions),
+                    deletions: parseInt(deletions),
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging commit:', logError);
+        }
+        return c.json({ success: true, data: { message, files: files ?? null, commitHash: sha } });
     }
     catch (e) {
         return c.json({ success: false, error: { message: e.message } }, 500);
@@ -273,6 +344,31 @@ app.post('/commits', async (c) => {
 app.post('/push', async (c) => {
     try {
         const result = await pushCurrent();
+        // Get current branch and remote info
+        try {
+            const { runGit } = await import('../../../../lib/git.js');
+            const { stdout: branchOutput } = await runGit(['branch', '--show-current']);
+            const currentBranch = branchOutput.trim();
+            const { stdout: remoteOutput } = await runGit(['config', '--get', `branch.${currentBranch}.remote`]);
+            const remoteName = remoteOutput.trim() || 'origin';
+            // Log push event
+            const session = await requireAuth(c);
+            const actor = session ? `human:${session.email}` : "human:unknown";
+            const logger = getLogger();
+            logger.log({
+                kind: CodeKinds.PUSH,
+                actor,
+                subject: `branch:${currentBranch}`,
+                tags: ["git", "push"],
+                payload: {
+                    branch: currentBranch,
+                    remote: remoteName,
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging push:', logError);
+        }
         return c.json({ success: true, data: { result } });
     }
     catch (e) {
@@ -288,6 +384,32 @@ app.post('/pull', async (c) => {
         catch { }
         const strategy = mode?.strategy === 'ff-only' || mode?.strategy === 'merge' ? mode.strategy : 'rebase';
         const result = await pullCurrent(strategy);
+        // Get current branch and remote info
+        try {
+            const { runGit } = await import('../../../../lib/git.js');
+            const { stdout: branchOutput } = await runGit(['branch', '--show-current']);
+            const currentBranch = branchOutput.trim();
+            const { stdout: remoteOutput } = await runGit(['config', '--get', `branch.${currentBranch}.remote`]);
+            const remoteName = remoteOutput.trim() || 'origin';
+            // Log pull event
+            const session = await requireAuth(c);
+            const actor = session ? `human:${session.email}` : "human:unknown";
+            const logger = getLogger();
+            logger.log({
+                kind: CodeKinds.PULL,
+                actor,
+                subject: `branch:${currentBranch}`,
+                tags: ["git", "pull"],
+                payload: {
+                    branch: currentBranch,
+                    remote: remoteName,
+                    strategy,
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging pull:', logError);
+        }
         return c.json({ success: true, data: { strategy, result } });
     }
     catch (e) {
@@ -312,6 +434,25 @@ app.post('/worktrees', async (c) => {
         if (!branch)
             return c.json({ success: false, error: { message: 'branch required' } }, 400);
         const added = await addWorktree(branch, from);
+        // Log worktree creation
+        try {
+            const session = await requireAuth(c);
+            const actor = session ? `human:${session.email}` : "human:unknown";
+            const logger = getLogger();
+            logger.log({
+                kind: CodeKinds.WORKTREE_ADD,
+                actor,
+                subject: `worktree:${added.branch}`,
+                tags: ["git", "worktree"],
+                payload: {
+                    path: added.path,
+                    branch: added.branch,
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging worktree creation:', logError);
+        }
         return c.json({ success: true, data: { added } });
     }
     catch (e) {

package/dist/routes/api/v1/identity/agent-card-service.d.ts

@@ -0,0 +1,11 @@
+export declare const AGENT_CARD_FILENAME = "agent-card.json";
+export declare const PUBLIC_AGENT_CARD_PATH = "/.well-known/agent-card.json";
+export interface AgentCardDocument {
+    exists: boolean;
+    card: unknown | null;
+    publicPath: string;
+    storagePath: string;
+    updatedAt?: string;
+}
+export declare function readAgentCard(): Promise<AgentCardDocument>;
+export declare function writeAgentCard(card: unknown): Promise<AgentCardDocument>;