instar 0.6.11 → 0.6.13

package/dist/core/AnthropicIntelligenceProvider.js

@@ -0,0 +1,68 @@
+/**
+ * AnthropicIntelligenceProvider — OPTIONAL IntelligenceProvider using the Anthropic Messages API.
+ *
+ * ⚠️  This provider uses API tokens (extra cost). For most Instar agents, the
+ * ClaudeCliIntelligenceProvider (which uses the Claude subscription) is the
+ * correct default. Only use this provider when:
+ *   - The user explicitly sets intelligenceProvider: "anthropic-api" in config
+ *   - The Claude CLI is not available
+ *   - The user has a specific reason to prefer direct API access
+ *
+ * No SDK dependency — direct fetch calls, following the TelegramAdapter pattern.
+ */
+const ANTHROPIC_API_URL = 'https://api.anthropic.com/v1/messages';
+const ANTHROPIC_API_VERSION = '2023-06-01';
+/** Model mapping: abstract tiers → concrete Anthropic model IDs */
+const MODEL_MAP = {
+    fast: 'claude-haiku-4-5-20251001',
+    balanced: 'claude-sonnet-4-5-20250514',
+    capable: 'claude-opus-4-0-20250514',
+};
+const DEFAULT_MODEL = 'fast';
+export class AnthropicIntelligenceProvider {
+    apiKey;
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    /**
+     * Create a provider from environment variables, or null if no key available.
+     * Follows the same graceful degradation pattern as TelegramAdapter's voice providers.
+     */
+    static fromEnv() {
+        const apiKey = process.env['ANTHROPIC_API_KEY'];
+        if (!apiKey) {
+            return null;
+        }
+        return new AnthropicIntelligenceProvider(apiKey);
+    }
+    async evaluate(prompt, options) {
+        const model = MODEL_MAP[options?.model ?? DEFAULT_MODEL] ?? MODEL_MAP[DEFAULT_MODEL];
+        const maxTokens = options?.maxTokens ?? 100;
+        const temperature = options?.temperature ?? 0;
+        const response = await fetch(ANTHROPIC_API_URL, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.apiKey,
+                'anthropic-version': ANTHROPIC_API_VERSION,
+            },
+            body: JSON.stringify({
+                model,
+                max_tokens: maxTokens,
+                temperature,
+                messages: [
+                    { role: 'user', content: prompt },
+                ],
+            }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => 'unknown error');
+            throw new Error(`Anthropic API error ${response.status}: ${errorText}`);
+        }
+        const data = await response.json();
+        // Extract text from the response
+        const textBlock = data.content?.find((block) => block.type === 'text');
+        return textBlock?.text ?? '';
+    }
+}
+//# sourceMappingURL=AnthropicIntelligenceProvider.js.map

package/dist/core/ClaudeCliIntelligenceProvider.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ClaudeCliIntelligenceProvider — Default IntelligenceProvider using the Claude CLI.
+ *
+ * Uses `claude -p` (print mode) to make judgment calls via the user's existing
+ * Claude subscription. Zero extra cost — the subscription is already paid for.
+ *
+ * This is the DEFAULT provider for Instar agents. The Anthropic API provider
+ * (AnthropicIntelligenceProvider) is an explicit opt-in alternative for users
+ * who intentionally choose direct API access.
+ *
+ * Preference hierarchy:
+ *   1. Claude CLI (subscription) — default, always available
+ *   2. Anthropic API — explicit user choice only
+ */
+import type { IntelligenceProvider, IntelligenceOptions } from './types.js';
+export declare class ClaudeCliIntelligenceProvider implements IntelligenceProvider {
+    private claudePath;
+    constructor(claudePath: string);
+    evaluate(prompt: string, options?: IntelligenceOptions): Promise<string>;
+}
+//# sourceMappingURL=ClaudeCliIntelligenceProvider.d.ts.map

package/dist/core/ClaudeCliIntelligenceProvider.js

@@ -0,0 +1,59 @@
+/**
+ * ClaudeCliIntelligenceProvider — Default IntelligenceProvider using the Claude CLI.
+ *
+ * Uses `claude -p` (print mode) to make judgment calls via the user's existing
+ * Claude subscription. Zero extra cost — the subscription is already paid for.
+ *
+ * This is the DEFAULT provider for Instar agents. The Anthropic API provider
+ * (AnthropicIntelligenceProvider) is an explicit opt-in alternative for users
+ * who intentionally choose direct API access.
+ *
+ * Preference hierarchy:
+ *   1. Claude CLI (subscription) — default, always available
+ *   2. Anthropic API — explicit user choice only
+ */
+import { execFile } from 'node:child_process';
+/** Model mapping: abstract tiers → Claude CLI model flags */
+const MODEL_MAP = {
+    fast: 'haiku',
+    balanced: 'sonnet',
+    capable: 'opus',
+};
+const DEFAULT_MODEL = 'fast';
+const DEFAULT_TIMEOUT_MS = 30_000;
+export class ClaudeCliIntelligenceProvider {
+    claudePath;
+    constructor(claudePath) {
+        this.claudePath = claudePath;
+    }
+    async evaluate(prompt, options) {
+        const model = MODEL_MAP[options?.model ?? DEFAULT_MODEL] ?? MODEL_MAP[DEFAULT_MODEL];
+        const maxTokens = options?.maxTokens ?? 100;
+        return new Promise((resolve, reject) => {
+            const args = [
+                '-p', prompt,
+                '--model', model,
+                '--max-turns', '1',
+                '--output-format', 'text',
+            ];
+            if (maxTokens) {
+                args.push('--max-tokens', String(maxTokens));
+            }
+            const child = execFile(this.claudePath, args, {
+                timeout: DEFAULT_TIMEOUT_MS,
+                maxBuffer: 1024 * 1024, // 1MB
+                env: { ...process.env },
+            }, (error, stdout, stderr) => {
+                if (error) {
+                    // Timeout or other error — return empty so caller can fall back
+                    reject(new Error(`Claude CLI error: ${error.message}${stderr ? ` — ${stderr.slice(0, 200)}` : ''}`));
+                    return;
+                }
+                resolve(stdout.trim());
+            });
+            // Write prompt via stdin for very long prompts (belt and suspenders)
+            child.stdin?.end();
+        });
+    }
+}
+//# sourceMappingURL=ClaudeCliIntelligenceProvider.js.map

package/dist/core/EvolutionManager.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Evolution Manager — the feedback loop that turns running into evolving.
+ *
+ * Four subsystems, one principle: every interaction is an opportunity
+ * to improve. Not during batch reflection hours later, but at the
+ * moment the insight is freshest.
+ *
+ * Subsystems:
+ * 1. Evolution Queue — staged self-improvement proposals
+ * 2. Learning Registry — structured, searchable insights
+ * 3. Capability Gap Tracker — "what am I missing?"
+ * 4. Action Queue — commitment tracking with stale detection
+ *
+ * Born from Portal's engagement pipeline (Steps 8-11) and proven
+ * across 100+ evolution proposals and 10 platform engagement skills.
+ */
+import type { EvolutionProposal, EvolutionType, EvolutionStatus, LearningEntry, LearningSource, CapabilityGap, GapCategory, ActionItem, EvolutionManagerConfig } from './types.js';
+interface EvolutionState {
+    proposals: EvolutionProposal[];
+    stats: {
+        totalProposals: number;
+        byStatus: Record<string, number>;
+        byType: Record<string, number>;
+        lastUpdated: string;
+    };
+}
+interface LearningState {
+    learnings: LearningEntry[];
+    stats: {
+        totalLearnings: number;
+        applied: number;
+        pending: number;
+        byCategory: Record<string, number>;
+        lastUpdated: string;
+    };
+}
+interface GapState {
+    gaps: CapabilityGap[];
+    stats: {
+        totalGaps: number;
+        bySeverity: Record<string, number>;
+        byCategory: Record<string, number>;
+        addressed: number;
+        lastUpdated: string;
+    };
+}
+interface ActionState {
+    actions: ActionItem[];
+    stats: {
+        totalActions: number;
+        pending: number;
+        completed: number;
+        overdue: number;
+        lastUpdated: string;
+    };
+}
+export declare class EvolutionManager {
+    private stateDir;
+    private config;
+    constructor(config: EvolutionManagerConfig);
+    private filePath;
+    private readFile;
+    private writeFile;
+    private now;
+    private loadEvolution;
+    private saveEvolution;
+    private nextProposalId;
+    addProposal(opts: {
+        title: string;
+        source: string;
+        description: string;
+        type: EvolutionType;
+        impact?: 'high' | 'medium' | 'low';
+        effort?: 'high' | 'medium' | 'low';
+        proposedBy?: string;
+        tags?: string[];
+    }): EvolutionProposal;
+    updateProposalStatus(id: string, status: EvolutionStatus, resolution?: string): boolean;
+    listProposals(filter?: {
+        status?: EvolutionStatus;
+        type?: EvolutionType;
+    }): EvolutionProposal[];
+    getEvolutionStats(): EvolutionState['stats'];
+    private loadLearnings;
+    private saveLearnings;
+    private nextLearningId;
+    addLearning(opts: {
+        title: string;
+        category: string;
+        description: string;
+        source: LearningSource;
+        tags?: string[];
+        evolutionRelevance?: string;
+    }): LearningEntry;
+    markLearningApplied(id: string, appliedTo: string): boolean;
+    listLearnings(filter?: {
+        category?: string;
+        applied?: boolean;
+    }): LearningEntry[];
+    getLearningStats(): LearningState['stats'];
+    private loadGaps;
+    private saveGaps;
+    private nextGapId;
+    addGap(opts: {
+        title: string;
+        category: GapCategory;
+        severity: 'critical' | 'high' | 'medium' | 'low';
+        description: string;
+        context: string;
+        platform?: string;
+        session?: string;
+        currentState?: string;
+        proposedSolution?: string;
+    }): CapabilityGap;
+    addressGap(id: string, resolution: string): boolean;
+    listGaps(filter?: {
+        severity?: string;
+        category?: GapCategory;
+        status?: string;
+    }): CapabilityGap[];
+    getGapStats(): GapState['stats'];
+    private loadActions;
+    private saveActions;
+    private nextActionId;
+    addAction(opts: {
+        title: string;
+        description: string;
+        priority?: 'critical' | 'high' | 'medium' | 'low';
+        commitTo?: string;
+        dueBy?: string;
+        source?: ActionItem['source'];
+        tags?: string[];
+    }): ActionItem;
+    updateAction(id: string, updates: {
+        status?: ActionItem['status'];
+        resolution?: string;
+    }): boolean;
+    listActions(filter?: {
+        status?: ActionItem['status'];
+        priority?: string;
+    }): ActionItem[];
+    getOverdueActions(): ActionItem[];
+    getActionStats(): ActionState['stats'];
+    /**
+     * Get a full dashboard of evolution health.
+     * Useful for session-start orientation and status reporting.
+     */
+    getDashboard(): {
+        evolution: EvolutionState['stats'];
+        learnings: LearningState['stats'];
+        gaps: GapState['stats'];
+        actions: ActionState['stats'];
+        highlights: string[];
+    };
+}
+export {};
+//# sourceMappingURL=EvolutionManager.d.ts.map