clementine-agent 1.0.0

package/dist/agent/auto-update.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Clementine TypeScript — Daemon-Driven Auto-Update.
+ *
+ * Checks for and applies upstream changes without requiring `clementine update`.
+ * Source modifications from self-improve are tracked in ~/.clementine/ (not git),
+ * so git pull is always clean. After pulling, source mods are reconciled.
+ */
+export interface UpdateCheckResult {
+    available: boolean;
+    commitsBehind: number;
+    summary?: string;
+}
+export interface UpdateApplyResult {
+    success: boolean;
+    error?: string;
+    reconcileResult?: import('./source-mods.js').ReconcileResult;
+}
+/**
+ * Check if upstream has new commits. Safe to call from cron — no side effects.
+ */
+export declare function checkForUpdates(pkgDir: string): Promise<UpdateCheckResult>;
+/**
+ * Apply upstream updates:
+ *   1. Reset any uncommitted src/ changes (mods are tracked in ~/.clementine/)
+ *   2. Pull latest from origin/main
+ *   3. Install deps + build
+ *   4. Reconcile source modifications
+ *   5. Rebuild if mods were re-applied
+ *   6. Write sentinel + restart
+ */
+export declare function applyUpdate(pkgDir: string): Promise<UpdateApplyResult>;
+//# sourceMappingURL=auto-update.d.ts.map

package/dist/agent/auto-update.js

@@ -0,0 +1,186 @@
+/**
+ * Clementine TypeScript — Daemon-Driven Auto-Update.
+ *
+ * Checks for and applies upstream changes without requiring `clementine update`.
+ * Source modifications from self-improve are tracked in ~/.clementine/ (not git),
+ * so git pull is always clean. After pulling, source mods are reconciled.
+ */
+import { execSync } from 'node:child_process';
+import { writeFileSync } from 'node:fs';
+import path from 'node:path';
+import pino from 'pino';
+import { BASE_DIR } from '../config.js';
+import { reconcileSourceMods } from './source-mods.js';
+const logger = pino({ name: 'clementine.auto-update' });
+const SENTINEL_PATH = path.join(BASE_DIR, '.restart-sentinel.json');
+/**
+ * Check if upstream has new commits. Safe to call from cron — no side effects.
+ */
+export async function checkForUpdates(pkgDir) {
+    try {
+        execSync('git fetch origin main --quiet', {
+            cwd: pkgDir,
+            stdio: 'pipe',
+            timeout: 30_000,
+        });
+        const countStr = execSync('git rev-list HEAD..origin/main --count', {
+            cwd: pkgDir,
+            encoding: 'utf-8',
+        }).trim();
+        const commitsBehind = parseInt(countStr, 10) || 0;
+        if (commitsBehind === 0) {
+            return { available: false, commitsBehind: 0 };
+        }
+        const summary = execSync('git log HEAD..origin/main --oneline', {
+            cwd: pkgDir,
+            encoding: 'utf-8',
+        }).trim();
+        return { available: true, commitsBehind, summary };
+    }
+    catch (err) {
+        logger.warn({ err }, 'Update check failed (network issue?)');
+        return { available: false, commitsBehind: 0 };
+    }
+}
+/**
+ * Apply upstream updates:
+ *   1. Reset any uncommitted src/ changes (mods are tracked in ~/.clementine/)
+ *   2. Pull latest from origin/main
+ *   3. Install deps + build
+ *   4. Reconcile source modifications
+ *   5. Rebuild if mods were re-applied
+ *   6. Write sentinel + restart
+ */
+export async function applyUpdate(pkgDir) {
+    try {
+        // 1. Ensure we're on main and clean
+        try {
+            const currentBranch = execSync('git rev-parse --abbrev-ref HEAD', {
+                cwd: pkgDir,
+                encoding: 'utf-8',
+            }).trim();
+            if (currentBranch !== 'main') {
+                execSync('git checkout main', { cwd: pkgDir, stdio: 'pipe' });
+            }
+        }
+        catch { /* best effort */ }
+        // Reset any local src/ changes (source mods are tracked in registry, not git)
+        try {
+            execSync('git checkout -- src/', { cwd: pkgDir, stdio: 'pipe' });
+        }
+        catch { /* no changes to reset */ }
+        // 2. Pull from origin
+        try {
+            execSync('git pull --ff-only origin main', {
+                cwd: pkgDir,
+                stdio: 'pipe',
+                timeout: 60_000,
+            });
+            logger.info('Pulled latest from origin/main');
+        }
+        catch (err) {
+            logger.error({ err }, 'git pull --ff-only failed');
+            return { success: false, error: `git pull failed: ${String(err)}` };
+        }
+        // 3. Install dependencies (in case they changed)
+        // Include devDependencies — typescript is needed for the build step
+        try {
+            execSync('npm install', {
+                cwd: pkgDir,
+                stdio: 'pipe',
+                timeout: 120_000,
+            });
+        }
+        catch (err) {
+            logger.warn({ err }, 'npm install failed during update');
+            // Non-fatal — build may still work
+        }
+        // 3b. Rebuild native modules (better-sqlite3) for current Node version
+        // The postinstall hook silently swallows errors, so do this explicitly.
+        try {
+            execSync('npm rebuild better-sqlite3', {
+                cwd: pkgDir,
+                stdio: 'pipe',
+                timeout: 60_000,
+            });
+            logger.info('Native module rebuild succeeded');
+        }
+        catch (err) {
+            logger.warn({ err }, 'npm rebuild better-sqlite3 failed — memory may not work after restart');
+        }
+        // 4. Build — use local tsc binary directly (npx can fail if typescript isn't cached)
+        try {
+            execSync('./node_modules/.bin/tsc', {
+                cwd: pkgDir,
+                stdio: 'pipe',
+                timeout: 120_000,
+            });
+            logger.info('Build succeeded after update');
+        }
+        catch (err) {
+            logger.error({ err }, 'Build failed after update');
+            return { success: false, error: `Build failed after update: ${String(err)}` };
+        }
+        // 5. Reconcile source modifications
+        const reconcileResult = reconcileSourceMods(pkgDir);
+        logger.info({
+            reapplied: reconcileResult.reapplied.length,
+            superseded: reconcileResult.superseded.length,
+            needsReconciliation: reconcileResult.needsReconciliation.length,
+            failed: reconcileResult.failed.length,
+        }, 'Source mod reconciliation complete');
+        // 6. Rebuild if any mods were re-applied
+        if (reconcileResult.reapplied.length > 0) {
+            try {
+                execSync('./node_modules/.bin/tsc', { cwd: pkgDir, stdio: 'pipe', timeout: 120_000 });
+                logger.info('Rebuild succeeded after re-applying source mods');
+            }
+            catch (err) {
+                logger.warn({ err }, 'Rebuild failed after re-applying source mods');
+            }
+        }
+        // 6b. Run vault migrations
+        try {
+            const { runVaultMigrations } = await import('../vault-migrations/runner.js');
+            const migResult = await runVaultMigrations(path.join(BASE_DIR, 'vault'));
+            logger.info({
+                applied: migResult.applied.length,
+                skipped: migResult.skipped.length,
+                failed: migResult.failed.length,
+            }, 'Vault migrations complete');
+        }
+        catch (err) {
+            logger.warn({ err }, 'Vault migration failed (non-fatal)');
+        }
+        // 7. Get version info and write sentinel + restart
+        let commitHash = '';
+        let commitDate = '';
+        try {
+            commitHash = execSync('git rev-parse --short HEAD', { cwd: pkgDir, encoding: 'utf-8' }).trim();
+            commitDate = execSync('git log -1 --format=%ci HEAD', { cwd: pkgDir, encoding: 'utf-8' }).trim().slice(0, 10);
+            // Count would have been calculated pre-pull; approximate from reconcile context
+        }
+        catch { /* best effort */ }
+        const sentinel = {
+            previousPid: process.pid,
+            restartedAt: new Date().toISOString(),
+            reason: 'update',
+            updateDetails: {
+                commitHash,
+                commitDate,
+                modsReapplied: reconcileResult.reapplied.length,
+                modsSuperseded: reconcileResult.superseded.length,
+                modsNeedReconciliation: reconcileResult.needsReconciliation.length,
+                modsFailed: reconcileResult.failed.length,
+            },
+        };
+        writeFileSync(SENTINEL_PATH, JSON.stringify(sentinel, null, 2));
+        process.kill(process.pid, 'SIGUSR1');
+        return { success: true, reconcileResult };
+    }
+    catch (err) {
+        logger.error({ err }, 'Update apply failed');
+        return { success: false, error: String(err) };
+    }
+}
+//# sourceMappingURL=auto-update.js.map

package/dist/agent/daily-planner.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Clementine TypeScript — Daily Planning Session.
+ *
+ * Gathers context from goals, cron runs, reflections, tasks, and inbox,
+ * then uses a lightweight Haiku call to produce a prioritized daily plan.
+ * Plans are persisted to ~/.clementine/plans/daily/{date}.json.
+ */
+import type { DailyPlan } from '../types.js';
+export declare class DailyPlanner {
+    constructor();
+    hasPlanForToday(): boolean;
+    getPlan(date?: string): DailyPlan | null;
+    plan(): Promise<DailyPlan>;
+    private gatherContext;
+    private loadActiveGoals;
+    private loadRecentCronFailures;
+    private loadRecentReflections;
+    private loadPendingTasks;
+    private countInboxItems;
+    private loadDelegatedTasks;
+    private generatePlan;
+    private fallbackPlan;
+}
+//# sourceMappingURL=daily-planner.d.ts.map

package/dist/agent/daily-planner.js

@@ -0,0 +1,379 @@
+/**
+ * Clementine TypeScript — Daily Planning Session.
+ *
+ * Gathers context from goals, cron runs, reflections, tasks, and inbox,
+ * then uses a lightweight Haiku call to produce a prioritized daily plan.
+ * Plans are persisted to ~/.clementine/plans/daily/{date}.json.
+ */
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import pino from 'pino';
+import Anthropic from '@anthropic-ai/sdk';
+import { BASE_DIR, GOALS_DIR, CRON_REFLECTIONS_DIR, TASKS_FILE, INBOX_DIR, MODELS, } from '../config.js';
+const logger = pino({ name: 'clementine.daily-planner' });
+const PLANS_DIR = path.join(BASE_DIR, 'plans', 'daily');
+// ── .env reader (self-contained — no config.ts secret imports) ───────
+function getEnvValue(key) {
+    // Check process env first (already loaded by the daemon)
+    if (process.env[key])
+        return process.env[key];
+    // Fall back to .env file
+    const envPath = path.join(BASE_DIR, '.env');
+    if (!existsSync(envPath))
+        return '';
+    for (const line of readFileSync(envPath, 'utf-8').split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const eqIndex = trimmed.indexOf('=');
+        if (eqIndex === -1)
+            continue;
+        if (trimmed.slice(0, eqIndex) !== key)
+            continue;
+        let value = trimmed.slice(eqIndex + 1);
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        return value;
+    }
+    return '';
+}
+/**
+ * Build Anthropic client credentials.
+ * Priority: ANTHROPIC_AUTH_TOKEN (OAuth) > ANTHROPIC_API_KEY (legacy raw key).
+ * Returns null if neither is configured.
+ */
+function getAnthropicCredentials() {
+    const oauthToken = getEnvValue('CLAUDE_CODE_OAUTH_TOKEN');
+    if (oauthToken)
+        return { authToken: oauthToken };
+    const authToken = getEnvValue('ANTHROPIC_AUTH_TOKEN');
+    if (authToken)
+        return { authToken };
+    const apiKey = getEnvValue('ANTHROPIC_API_KEY');
+    if (apiKey)
+        return { apiKey };
+    return null;
+}
+// ── Helpers ──────────────────────────────────────────────────────────
+function todayStr() {
+    const d = new Date();
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+}
+// ── DailyPlanner ────────────────────────────────────────────────────
+export class DailyPlanner {
+    constructor() {
+        if (!existsSync(PLANS_DIR)) {
+            mkdirSync(PLANS_DIR, { recursive: true });
+        }
+    }
+    hasPlanForToday() {
+        const planPath = path.join(PLANS_DIR, `${todayStr()}.json`);
+        return existsSync(planPath);
+    }
+    getPlan(date) {
+        const d = date ?? todayStr();
+        const planPath = path.join(PLANS_DIR, `${d}.json`);
+        if (!existsSync(planPath))
+            return null;
+        try {
+            return JSON.parse(readFileSync(planPath, 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    async plan() {
+        const context = this.gatherContext();
+        const plan = await this.generatePlan(context);
+        const planPath = path.join(PLANS_DIR, `${plan.date}.json`);
+        writeFileSync(planPath, JSON.stringify(plan, null, 2));
+        logger.info({ date: plan.date, priorities: plan.priorities.length }, 'Daily plan generated');
+        return plan;
+    }
+    // ── Context Gathering ───────────────────────────────────────────────
+    gatherContext() {
+        const sections = [];
+        // Active goals
+        const goals = this.loadActiveGoals();
+        if (goals.length > 0) {
+            const goalLines = goals.map(g => {
+                const parts = [`- "${g.title}" (${g.priority} priority, owner: ${g.owner})`];
+                if (g.nextActions?.length)
+                    parts.push(`  Next: ${g.nextActions.slice(0, 3).join('; ')}`);
+                if (g.blockers?.length)
+                    parts.push(`  Blockers: ${g.blockers.join('; ')}`);
+                if (g.targetDate)
+                    parts.push(`  Target: ${g.targetDate}`);
+                return parts.join('\n');
+            });
+            sections.push(`## Active Goals (${goals.length})\n${goalLines.join('\n')}`);
+        }
+        // Recent cron failures (last 24h)
+        const failures = this.loadRecentCronFailures();
+        if (failures.length > 0) {
+            const failLines = failures.map(f => `- ${f.jobName}: ${f.error ?? 'unknown error'} (${f.finishedAt})`);
+            sections.push(`## Recent Cron Failures (last 24h)\n${failLines.join('\n')}`);
+        }
+        // Recent reflections
+        const reflections = this.loadRecentReflections();
+        if (reflections.length > 0) {
+            const refLines = reflections.map(r => `- ${r.jobName} (quality: ${r.quality}/5): ${r.gap || 'no gap noted'}`);
+            sections.push(`## Recent Cron Reflections\n${refLines.join('\n')}`);
+        }
+        // Pending tasks
+        const pendingTasks = this.loadPendingTasks();
+        if (pendingTasks.length > 0) {
+            sections.push(`## Pending Tasks (${pendingTasks.length})\n${pendingTasks.slice(0, 15).map(t => `- ${t}`).join('\n')}`);
+        }
+        // Inbox
+        const inboxCount = this.countInboxItems();
+        if (inboxCount > 0) {
+            sections.push(`## Inbox\n${inboxCount} unprocessed item(s)`);
+        }
+        // Delegated tasks
+        const delegated = this.loadDelegatedTasks();
+        if (delegated.length > 0) {
+            sections.push(`## Delegated Tasks (${delegated.length})\n${delegated.map(d => `- [${d.status}] ${d.task} (to: ${d.toAgent})`).join('\n')}`);
+        }
+        return sections.join('\n\n') || 'No context available — all clear.';
+    }
+    loadActiveGoals() {
+        if (!existsSync(GOALS_DIR))
+            return [];
+        try {
+            const files = readdirSync(GOALS_DIR).filter(f => f.endsWith('.json'));
+            const goals = [];
+            for (const f of files) {
+                try {
+                    const goal = JSON.parse(readFileSync(path.join(GOALS_DIR, f), 'utf-8'));
+                    if (goal.status === 'active')
+                        goals.push(goal);
+                }
+                catch {
+                    continue;
+                }
+            }
+            return goals.sort((a, b) => {
+                const p = { high: 0, medium: 1, low: 2 };
+                return (p[a.priority] ?? 2) - (p[b.priority] ?? 2);
+            });
+        }
+        catch {
+            return [];
+        }
+    }
+    loadRecentCronFailures() {
+        const runDir = path.join(BASE_DIR, 'cron', 'runs');
+        if (!existsSync(runDir))
+            return [];
+        const cutoff = Date.now() - 86_400_000;
+        const failures = [];
+        try {
+            for (const f of readdirSync(runDir).filter(f => f.endsWith('.jsonl'))) {
+                try {
+                    const lines = readFileSync(path.join(runDir, f), 'utf-8').trim().split('\n').filter(Boolean);
+                    for (const line of lines.slice(-10)) {
+                        try {
+                            const entry = JSON.parse(line);
+                            if (entry.status !== 'ok' && entry.finishedAt && new Date(entry.finishedAt).getTime() > cutoff) {
+                                failures.push({ jobName: entry.jobName ?? f.replace('.jsonl', ''), error: entry.error, finishedAt: entry.finishedAt });
+                            }
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        catch { /* non-fatal */ }
+        return failures;
+    }
+    loadRecentReflections() {
+        if (!existsSync(CRON_REFLECTIONS_DIR))
+            return [];
+        const results = [];
+        try {
+            for (const f of readdirSync(CRON_REFLECTIONS_DIR).filter(f => f.endsWith('.jsonl'))) {
+                try {
+                    const lines = readFileSync(path.join(CRON_REFLECTIONS_DIR, f), 'utf-8').trim().split('\n').filter(Boolean);
+                    const recent = lines.slice(-5);
+                    for (const line of recent) {
+                        try {
+                            const entry = JSON.parse(line);
+                            results.push({ jobName: entry.jobName ?? f.replace('.jsonl', ''), quality: entry.quality ?? 0, gap: entry.gap ?? '' });
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        catch { /* non-fatal */ }
+        return results;
+    }
+    loadPendingTasks() {
+        if (!existsSync(TASKS_FILE))
+            return [];
+        try {
+            const content = readFileSync(TASKS_FILE, 'utf-8');
+            return content.split('\n')
+                .filter(line => /^\s*- \[ \]/.test(line))
+                .map(line => line.trim().replace(/^- \[ \]\s*/, ''));
+        }
+        catch {
+            return [];
+        }
+    }
+    countInboxItems() {
+        if (!existsSync(INBOX_DIR))
+            return 0;
+        try {
+            return readdirSync(INBOX_DIR).filter(f => f.endsWith('.md') && !f.startsWith('_')).length;
+        }
+        catch {
+            return 0;
+        }
+    }
+    loadDelegatedTasks() {
+        const delegationsDir = path.join(BASE_DIR, 'vault', '00-System', 'agents');
+        if (!existsSync(delegationsDir))
+            return [];
+        const results = [];
+        try {
+            for (const agentDir of readdirSync(delegationsDir)) {
+                const tasksDir = path.join(delegationsDir, agentDir, 'delegations');
+                if (!existsSync(tasksDir))
+                    continue;
+                try {
+                    for (const f of readdirSync(tasksDir).filter(f => f.endsWith('.json'))) {
+                        try {
+                            const task = JSON.parse(readFileSync(path.join(tasksDir, f), 'utf-8'));
+                            if (task.status !== 'completed') {
+                                results.push({ task: task.task ?? f, toAgent: task.toAgent ?? agentDir, status: task.status ?? 'pending' });
+                            }
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        catch { /* non-fatal */ }
+        return results;
+    }
+    // ── Plan Generation ─────────────────────────────────────────────────
+    async generatePlan(context) {
+        const today = todayStr();
+        const prompt = `Today is ${today}. Based on the following context about active goals, tasks, cron job health, and inbox items, produce a prioritized daily plan.
+
+${context}
+
+Respond with a JSON object (no markdown fencing) matching this schema:
+{
+  "date": "${today}",
+  "createdAt": "<ISO timestamp>",
+  "priorities": [
+    { "type": "goal|task|cron-fix|inbox", "id": "<goal-id or description>", "action": "<what to do>", "urgency": <1-5> }
+  ],
+  "suggestedCronChanges": [
+    { "job": "<job name>", "change": "adjust-schedule|adjust-prompt|disable", "reason": "<why>" }
+  ],
+  "newWork": [
+    { "description": "<what to do>", "goalId": "<optional goal id>", "suggestedSchedule": "<optional cron expression>" }
+  ],
+  "summary": "<2-3 sentence summary of the day's focus>"
+}
+
+Rules:
+- Urgency 5 = critical/overdue, 1 = nice-to-have
+- Limit to at most 10 priorities, 5 cron changes, 5 new work items
+- Focus on actionable items, not status reports
+- If everything is on track, return minimal priorities`;
+        const creds = getAnthropicCredentials();
+        if (!creds) {
+            logger.warn('No Anthropic credentials found — generating fallback plan. Run `clementine login` to authenticate.');
+            return this.fallbackPlan(today);
+        }
+        try {
+            const client = new Anthropic(creds.authToken ? { authToken: creds.authToken } : { apiKey: creds.apiKey });
+            const response = await client.messages.create({
+                model: MODELS.haiku,
+                max_tokens: 2000,
+                messages: [{ role: 'user', content: prompt }],
+                system: 'You are a planning assistant. Analyze the context and produce a prioritized daily plan as JSON. Return only valid JSON, no markdown fencing.',
+            });
+            const text = response.content
+                .filter(block => block.type === 'text')
+                .map(block => block.text)
+                .join('');
+            const plan = JSON.parse(text);
+            plan.date = today;
+            plan.createdAt = new Date().toISOString();
+            plan.priorities = plan.priorities ?? [];
+            plan.suggestedCronChanges = plan.suggestedCronChanges ?? [];
+            plan.newWork = plan.newWork ?? [];
+            plan.summary = plan.summary ?? 'No summary generated.';
+            return plan;
+        }
+        catch (err) {
+            logger.warn({ err }, 'LLM plan generation failed — using fallback');
+            return this.fallbackPlan(today);
+        }
+    }
+    fallbackPlan(date) {
+        const priorities = [];
+        // Add high-priority goals
+        const goals = this.loadActiveGoals();
+        for (const g of goals.filter(g => g.priority === 'high').slice(0, 3)) {
+            priorities.push({
+                type: 'goal',
+                id: g.id,
+                action: g.nextActions?.[0] ?? `Review "${g.title}"`,
+                urgency: 4,
+            });
+        }
+        // Add cron failures
+        const failures = this.loadRecentCronFailures();
+        for (const f of failures.slice(0, 3)) {
+            priorities.push({
+                type: 'cron-fix',
+                id: f.jobName,
+                action: `Fix failing job: ${f.jobName}`,
+                urgency: 4,
+            });
+        }
+        // Add inbox
+        const inbox = this.countInboxItems();
+        if (inbox > 0) {
+            priorities.push({
+                type: 'inbox',
+                id: 'inbox',
+                action: `Process ${inbox} inbox item(s)`,
+                urgency: 2,
+            });
+        }
+        return {
+            date,
+            createdAt: new Date().toISOString(),
+            priorities,
+            suggestedCronChanges: [],
+            newWork: [],
+            summary: `Fallback plan: ${priorities.length} items to address. LLM planning unavailable.`,
+        };
+    }
+}
+//# sourceMappingURL=daily-planner.js.map

package/dist/agent/execution-advisor.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Clementine TypeScript — Execution Advisor.
+ *
+ * Analyzes recent run history and reflection data to adaptively tune
+ * cron job execution parameters: turn limits, models, timeouts, prompt
+ * enrichment, escalation, and circuit-breaking.
+ */
+import type { CronJobDefinition, ExecutionAdvice } from '../types.js';
+export declare function getExecutionAdvice(jobName: string, job: CronJobDefinition): ExecutionAdvice;
+//# sourceMappingURL=execution-advisor.d.ts.map