clementine-agent 1.0.0

package/dist/agent/strategic-planner.js

@@ -0,0 +1,352 @@
+/**
+ * Clementine TypeScript — Strategic Planner (Multi-Horizon Planning).
+ *
+ * Weekly reviews: synthesize daily plans + goal progress into accomplishments,
+ * missed targets, patterns, and recommendations.
+ *
+ * Monthly assessments: cross-reference weekly reviews with goal completion
+ * and self-improvement experiments. Proposes OKR-style goals.
+ *
+ * Plans are persisted to ~/.clementine/plans/weekly/ and monthly/.
+ */
+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, MODELS } from '../config.js';
+const logger = pino({ name: 'clementine.strategic-planner' });
+const DAILY_PLANS_DIR = path.join(BASE_DIR, 'plans', 'daily');
+const WEEKLY_PLANS_DIR = path.join(BASE_DIR, 'plans', 'weekly');
+const MONTHLY_PLANS_DIR = path.join(BASE_DIR, 'plans', 'monthly');
+// ── .env reader ──────────────────────────────────────────────────────
+function getEnvValue(key) {
+    if (process.env[key])
+        return process.env[key];
+    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 '';
+}
+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;
+}
+function makeAnthropicClient() {
+    const creds = getAnthropicCredentials();
+    if (!creds)
+        return null;
+    return new Anthropic(creds.authToken ? { authToken: creds.authToken } : { apiKey: creds.apiKey });
+}
+// ── Strategic Planner ────────────────────────────────────────────────
+export class StrategicPlanner {
+    constructor() {
+        mkdirSync(WEEKLY_PLANS_DIR, { recursive: true });
+        mkdirSync(MONTHLY_PLANS_DIR, { recursive: true });
+    }
+    // ── Weekly Review ────────────────────────────────────────────────────
+    hasWeeklyReview(weekId) {
+        const id = weekId ?? currentWeekId();
+        return existsSync(path.join(WEEKLY_PLANS_DIR, `${id}.json`));
+    }
+    async generateWeeklyReview() {
+        const weekId = currentWeekId();
+        const context = this.gatherWeeklyContext();
+        const review = await this.callLlmForWeekly(weekId, context);
+        writeFileSync(path.join(WEEKLY_PLANS_DIR, `${weekId}.json`), JSON.stringify(review, null, 2));
+        logger.info({ weekId, accomplishments: review.accomplishments.length }, 'Weekly review generated');
+        return review;
+    }
+    gatherWeeklyContext() {
+        const parts = [];
+        // Last 7 daily plans
+        const dailyPlans = this.loadRecentDailyPlans(7);
+        if (dailyPlans.length > 0) {
+            parts.push('## Daily Plans This Week');
+            for (const plan of dailyPlans) {
+                const priorities = plan.priorities.map(p => `  - [${p.type}] ${p.action} (urgency: ${p.urgency})`).join('\n');
+                parts.push(`### ${plan.date}\n${plan.summary}\n${priorities}`);
+            }
+        }
+        // Goal progress
+        const goals = this.loadActiveGoals();
+        if (goals.length > 0) {
+            parts.push('## Goal Status');
+            for (const goal of goals) {
+                const recentNotes = (goal.progressNotes ?? []).slice(-3).join('; ');
+                parts.push(`- [${goal.priority}] ${goal.title}: ${goal.status} | Notes: ${recentNotes || 'none'}`);
+            }
+        }
+        // Goal progress logs
+        const progressDir = path.join(GOALS_DIR, 'progress');
+        if (existsSync(progressDir)) {
+            const files = readdirSync(progressDir).filter(f => f.endsWith('.progress.jsonl'));
+            const weekAgo = new Date(Date.now() - 7 * 86_400_000).toISOString();
+            const entries = [];
+            for (const file of files.slice(0, 10)) {
+                const lines = readFileSync(path.join(progressDir, file), 'utf-8').trim().split('\n').filter(Boolean);
+                for (const line of lines.slice(-10)) {
+                    try {
+                        const entry = JSON.parse(line);
+                        if (entry.timestamp > weekAgo) {
+                            entries.push(`[${entry.status}] ${entry.focus}: ${entry.resultSnippet?.slice(0, 80)}`);
+                        }
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            }
+            if (entries.length > 0) {
+                parts.push(`## Goal Work Sessions This Week\n${entries.join('\n')}`);
+            }
+        }
+        return parts.join('\n\n');
+    }
+    async callLlmForWeekly(weekId, context) {
+        const goals = this.loadActiveGoals();
+        const prompt = `You are reviewing the week ${weekId}. Based on the context below, produce a weekly review.\n\n` +
+            `${context}\n\n` +
+            `Output ONLY a JSON object:\n` +
+            `{\n` +
+            `  "accomplishments": ["what was achieved"],\n` +
+            `  "missedTargets": ["what was planned but not done"],\n` +
+            `  "patterns": ["recurring themes or issues noticed"],\n` +
+            `  "recommendations": ["what to focus on next week"],\n` +
+            `  "summary": "2-3 sentence overall assessment"\n` +
+            `}`;
+        const defaultReview = {
+            weekId,
+            createdAt: new Date().toISOString(),
+            accomplishments: [],
+            missedTargets: [],
+            patterns: [],
+            recommendations: [],
+            goalProgress: goals.map(g => ({
+                goalId: g.id,
+                title: g.title,
+                status: g.status,
+                noteCount: g.progressNotes?.length ?? 0,
+            })),
+            summary: 'No data available for weekly review.',
+        };
+        const client = makeAnthropicClient();
+        if (!client)
+            return defaultReview;
+        try {
+            const response = await client.messages.create({
+                model: MODELS.haiku,
+                max_tokens: 1000,
+                messages: [{ role: 'user', content: prompt }],
+            });
+            const text = response.content[0]?.type === 'text' ? response.content[0].text : '';
+            const jsonMatch = text.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                const parsed = JSON.parse(jsonMatch[0]);
+                return {
+                    ...defaultReview,
+                    accomplishments: parsed.accomplishments ?? [],
+                    missedTargets: parsed.missedTargets ?? [],
+                    patterns: parsed.patterns ?? [],
+                    recommendations: parsed.recommendations ?? [],
+                    summary: parsed.summary ?? defaultReview.summary,
+                };
+            }
+        }
+        catch (err) {
+            logger.warn({ err }, 'Weekly review LLM call failed');
+        }
+        return defaultReview;
+    }
+    // ── Monthly Assessment ───────────────────────────────────────────────
+    hasMonthlyAssessment(monthId) {
+        const id = monthId ?? currentMonthId();
+        return existsSync(path.join(MONTHLY_PLANS_DIR, `${id}.json`));
+    }
+    async generateMonthlyAssessment() {
+        const monthId = currentMonthId();
+        const context = this.gatherMonthlyContext();
+        const assessment = await this.callLlmForMonthly(monthId, context);
+        writeFileSync(path.join(MONTHLY_PLANS_DIR, `${monthId}.json`), JSON.stringify(assessment, null, 2));
+        logger.info({ monthId }, 'Monthly assessment generated');
+        return assessment;
+    }
+    gatherMonthlyContext() {
+        const parts = [];
+        // Last 4 weekly reviews
+        const weeklyFiles = existsSync(WEEKLY_PLANS_DIR)
+            ? readdirSync(WEEKLY_PLANS_DIR).filter(f => f.endsWith('.json')).sort().slice(-4)
+            : [];
+        if (weeklyFiles.length > 0) {
+            parts.push('## Weekly Reviews');
+            for (const file of weeklyFiles) {
+                try {
+                    const review = JSON.parse(readFileSync(path.join(WEEKLY_PLANS_DIR, file), 'utf-8'));
+                    parts.push(`### ${review.weekId}\n${review.summary}`);
+                    if (review.patterns.length > 0) {
+                        parts.push(`Patterns: ${review.patterns.join('; ')}`);
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        // Goal completion stats
+        const goals = this.loadActiveGoals();
+        const allGoals = this.loadAllGoals();
+        const completed = allGoals.filter(g => g.status === 'completed');
+        parts.push(`## Goals: ${goals.length} active, ${completed.length} completed this period`);
+        return parts.join('\n\n');
+    }
+    async callLlmForMonthly(monthId, context) {
+        const allGoals = this.loadAllGoals();
+        const completed = allGoals.filter(g => g.status === 'completed').length;
+        const total = allGoals.length || 1;
+        const defaultAssessment = {
+            monthId,
+            createdAt: new Date().toISOString(),
+            weeklyTrends: [],
+            goalCompletionRate: completed / total,
+            systemicIssues: [],
+            proposedGoals: [],
+            summary: 'No data available for monthly assessment.',
+        };
+        const client2 = makeAnthropicClient();
+        if (!client2)
+            return defaultAssessment;
+        const prompt = `You are generating a monthly strategic assessment for ${monthId}.\n\n` +
+            `${context}\n\n` +
+            `Output ONLY a JSON object:\n` +
+            `{\n` +
+            `  "weeklyTrends": ["trends across the weekly reviews"],\n` +
+            `  "systemicIssues": ["recurring problems that need structural fixes"],\n` +
+            `  "proposedGoals": [{"title": "...", "description": "...", "priority": "high|medium|low"}],\n` +
+            `  "summary": "2-3 sentence strategic assessment"\n` +
+            `}`;
+        try {
+            const response = await client2.messages.create({
+                model: MODELS.haiku,
+                max_tokens: 1000,
+                messages: [{ role: 'user', content: prompt }],
+            });
+            const text = response.content[0]?.type === 'text' ? response.content[0].text : '';
+            const jsonMatch = text.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                const parsed = JSON.parse(jsonMatch[0]);
+                return {
+                    ...defaultAssessment,
+                    weeklyTrends: parsed.weeklyTrends ?? [],
+                    systemicIssues: parsed.systemicIssues ?? [],
+                    proposedGoals: parsed.proposedGoals ?? [],
+                    summary: parsed.summary ?? defaultAssessment.summary,
+                };
+            }
+        }
+        catch (err) {
+            logger.warn({ err }, 'Monthly assessment LLM call failed');
+        }
+        return defaultAssessment;
+    }
+    // ── Goal-Plan Alignment Check ────────────────────────────────────────
+    /**
+     * Check if today's daily plan aligns with active high-priority goals.
+     * Returns a warning string if misaligned, null if fine.
+     */
+    checkGoalPlanAlignment(dailyPlan) {
+        const goals = this.loadActiveGoals();
+        const highPriority = goals.filter(g => g.priority === 'high');
+        if (highPriority.length === 0)
+            return null;
+        // Check if any priority items reference a high-priority goal
+        const goalTitlesLower = highPriority.map(g => g.title.toLowerCase());
+        const priorityTexts = dailyPlan.priorities.map(p => p.action.toLowerCase());
+        const hasGoalWork = goalTitlesLower.some(title => priorityTexts.some(pt => pt.includes(title.slice(0, 20)) || pt.includes(title.split(' ')[0])));
+        // Also check if any priorities are of type 'goal'
+        const hasGoalType = dailyPlan.priorities.some(p => p.type === 'goal');
+        if (!hasGoalWork && !hasGoalType) {
+            const goalNames = highPriority.map(g => g.title).join(', ');
+            return `Today's plan doesn't directly advance any high-priority goals (${goalNames}). Consider scheduling focused work on at least one.`;
+        }
+        return null;
+    }
+    // ── Helpers ──────────────────────────────────────────────────────────
+    loadRecentDailyPlans(days) {
+        if (!existsSync(DAILY_PLANS_DIR))
+            return [];
+        const files = readdirSync(DAILY_PLANS_DIR).filter(f => f.endsWith('.json')).sort().slice(-days);
+        return files.map(f => {
+            try {
+                return JSON.parse(readFileSync(path.join(DAILY_PLANS_DIR, f), 'utf-8'));
+            }
+            catch {
+                return null;
+            }
+        }).filter(Boolean);
+    }
+    loadActiveGoals() {
+        if (!existsSync(GOALS_DIR))
+            return [];
+        return readdirSync(GOALS_DIR)
+            .filter(f => f.endsWith('.json'))
+            .map(f => {
+            try {
+                return JSON.parse(readFileSync(path.join(GOALS_DIR, f), 'utf-8'));
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((g) => g && g.status === 'active');
+    }
+    loadAllGoals() {
+        if (!existsSync(GOALS_DIR))
+            return [];
+        return readdirSync(GOALS_DIR)
+            .filter(f => f.endsWith('.json'))
+            .map(f => {
+            try {
+                return JSON.parse(readFileSync(path.join(GOALS_DIR, f), 'utf-8'));
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter(Boolean);
+    }
+}
+// ── Date helpers ───────────────────────────────────────────────────────
+function currentWeekId() {
+    const now = new Date();
+    const yearStart = new Date(now.getFullYear(), 0, 1);
+    const weekNum = Math.ceil(((now.getTime() - yearStart.getTime()) / 86_400_000 + yearStart.getDay() + 1) / 7);
+    return `${now.getFullYear()}-W${String(weekNum).padStart(2, '0')}`;
+}
+function currentMonthId() {
+    const now = new Date();
+    return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}`;
+}
+//# sourceMappingURL=strategic-planner.js.map

package/dist/agent/team-bus.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Clementine TypeScript — Inter-agent message bus.
+ *
+ * Enables async message passing between team agents via gateway.injectContext.
+ * Logs to JSONL and optionally mirrors to a Discord channel.
+ */
+import type { TeamMessage } from '../types.js';
+import type { Gateway } from '../gateway/router.js';
+import type { TeamRouter } from './team-router.js';
+export declare class TeamBus {
+    private gateway;
+    private teamRouter;
+    private commsChannelId?;
+    private logFile;
+    private recentMessages;
+    /** "from:to" → last send timestamp (for cooldown). */
+    private cooldowns;
+    /** "slug" → context shares sent today (resets at midnight). */
+    private contextShareCounts;
+    /** "from:to:contentHash" → timestamp (for content dedup). */
+    private contentHashes;
+    private statusChangeListeners;
+    private pendingRequests;
+    private botManager?;
+    private slackBotManager?;
+    constructor(gateway: Gateway, teamRouter: TeamRouter, options: {
+        commsChannelId?: string;
+        logFile: string;
+        botManager?: import('../channels/discord-bot-manager.js').BotManager;
+        slackBotManager?: import('../channels/slack-bot-manager.js').SlackBotManager;
+    });
+    /** Update the BotManager reference (called if set after construction). */
+    setBotManager(botManager: import('../channels/discord-bot-manager.js').BotManager): void;
+    /** Update the SlackBotManager reference (called if set after construction). */
+    setSlackBotManager(slackBotManager: import('../channels/slack-bot-manager.js').SlackBotManager): void;
+    /**
+     * Resolve a session key for the target agent via BotManager or SlackBotManager.
+     */
+    private resolveSessionKey;
+    /**
+     * Derive the agent slug that owns a given session key.
+     * Returns null for primary/owner sessions (no agent slug).
+     */
+    private deriveSlugFromSession;
+    /** Agent A sends a direct message to Agent B (fire-and-forget with cooldown/dedup). */
+    send(fromSlug: string, toSlug: string, content: string, depth?: number, sessionKey?: string): Promise<TeamMessage>;
+    /**
+     * Send a structured request and wait for the target agent's response.
+     * Bypasses cooldown — structured requests are explicitly tracked.
+     */
+    request(fromSlug: string, toSlug: string, content: string, timeoutMs?: number, sessionKey?: string): Promise<TeamMessage>;
+    /** Deliver a response to a pending structured request. */
+    respond(toRequestId: string, fromSlug: string, content: string, _sessionKey?: string): Promise<TeamMessage>;
+    /** Broadcast a message to all team agents (optionally scoped to a goal). */
+    broadcast(fromSlug: string, content: string, goalId: string, _sessionKey?: string): Promise<TeamMessage[]>;
+    /** Get pending structured requests addressed to an agent. */
+    getPendingRequests(agentSlug: string): Array<{
+        requestId: string;
+        fromAgent: string;
+        content: string;
+        timestamp: string;
+        expectedBy?: string;
+    }>;
+    /** Core delivery logic — sends a message via bot or session injection. */
+    private deliverMessage;
+    /** Register a listener that fires when team state changes. */
+    onStatusChange(cb: () => void): void;
+    /** Get recent inter-agent messages (for dashboard). */
+    getRecentMessages(limit?: number): TeamMessage[];
+    /** Get messages for a specific agent (sent or received). */
+    getMessagesForAgent(slug: string, limit?: number): TeamMessage[];
+    /** Load messages from the JSONL log file (cold start). */
+    loadFromLog(limit?: number): void;
+    /**
+     * Deliver any undelivered messages from the JSONL log.
+     * Called periodically by the daemon to pick up messages
+     * written by the MCP tool (which runs out-of-process).
+     */
+    deliverPending(): Promise<number>;
+    /** Post an embed to the team comms Discord channel. */
+    private mirrorToDiscord;
+    /**
+     * Share context between agents — lightweight, rate-limited updates.
+     * Longer cooldown (4 hours) and daily cap (2 per agent) vs regular messages.
+     * Used for proactive context sharing, not task delegation.
+     */
+    shareContext(fromSlug: string, toSlug: string, content: string): Promise<TeamMessage | null>;
+}
+//# sourceMappingURL=team-bus.d.ts.map