dual-brain 0.2.30 → 0.3.0

package/dist/src/profile.d.ts

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+/**
+ * profile.ts — User profile module for the Dual-Brain Orchestrator.
+ *
+ * Exported API:
+ *   loadProfile(cwd)               → profile (or defaults)
+ *   saveProfile(profile, opts)     → write project or global file
+ *   ensureProfile(cwd, opts)       → load or onboard
+ *   runOnboarding(opts)            → interactive 3-question setup
+ *   rememberPreference(text, opts) → add/update preference
+ *   forgetPreference(text, cwd)    → remove preference by fuzzy match
+ *   getActivePreferences(cwd)      → enabled global + project preferences
+ *   getAvailableProviders(profile) → enabled providers
+ *   isSoloBrain(profile)           → true if only one provider enabled
+ *   getHeadModel(profile)          → suggested head model string
+ *   detectCapabilities(cwd)        → what we can actually verify
+ *   getOnboardingMessage(caps, ws) → honest 2-3 line status message
+ *   detectCapabilities(cwd)        → available providers (subscription-based only)
+ *
+ * CLI:
+ *   node src/profile.mjs                  # show current profile
+ *   node src/profile.mjs --init           # run onboarding
+ *   node src/profile.mjs --remember "…"   # add preference
+ *   node src/profile.mjs --forget "…"     # remove preference
+ *   node src/profile.mjs --providers      # show available providers
+ */
+import { Interface as ReadlineInterface } from 'readline';
+export interface Preference {
+    text: string;
+    enabled: boolean;
+    scope: 'one-off' | 'project' | 'global';
+}
+export interface ProviderConfig {
+    enabled: boolean;
+    plan?: string;
+    label?: string;
+    expiresAt?: string;
+    subs?: unknown;
+}
+export interface Profile {
+    schemaVersion: number;
+    createdAt: string;
+    updatedAt: string;
+    workStyle: string;
+    providers: Record<string, ProviderConfig>;
+    mode: string;
+    bias: string;
+    preferences: Preference[];
+    apiGuardrail: boolean;
+    capabilities?: DetectedCapabilities;
+    detectedAt?: string;
+    forbiddenModels?: string[];
+    preferredModels?: string[];
+    costBias?: number;
+    subscription?: unknown;
+    budget?: unknown;
+    detectedPlan?: unknown;
+    plan?: unknown;
+    price?: unknown;
+    subscriptions?: Record<string, unknown>;
+}
+export interface DetectedCapabilities {
+    claude: {
+        available: boolean;
+        source: string | null;
+    };
+    openai: {
+        available: boolean;
+        source: string | null;
+    };
+    codex: {
+        available: boolean;
+        source: string | null;
+    };
+    replitTools: {
+        available: boolean;
+        checkpoints: boolean;
+    };
+    mcpServers: string[];
+    claudePlugins: string[];
+    codexPlugins: string[];
+    shellSnapshots: number;
+    configuredHooks: Record<string, number>;
+}
+export interface EnvironmentInfo {
+    isReplit: boolean;
+    hasReplitTools: boolean;
+    isCI: boolean;
+}
+export interface AutoSetupResult {
+    confident: boolean;
+    profile: Profile | null;
+    warnings: string[];
+    actions: string[];
+}
+export interface TokenRefreshResult {
+    status: string;
+    hoursRemaining?: number;
+    error?: string;
+    delegatedTo?: string;
+}
+export interface AuthEntry {
+    found: boolean;
+    source: string | null;
+    loginType: 'oauth' | 'cli' | null;
+}
+export interface AuthDetectionResult {
+    claude: AuthEntry;
+    openai: AuthEntry;
+}
+export interface Credential {
+    id: string;
+    provider: string;
+    auth_type: string;
+    source: string;
+    owner?: string;
+    scope?: string;
+    plan_hint?: string | null;
+    enabled?: boolean;
+    health?: string;
+    last_checked_at?: string | null;
+    secret?: string;
+    token?: string;
+    api_key?: string;
+    password?: string;
+}
+export interface CredentialStore {
+    version: number;
+    credentials: Credential[];
+}
+export interface CapabilityManifest {
+    providers: {
+        claude: ProviderManifestEntry;
+        openai: ProviderManifestEntry;
+    };
+    preferences: ManifestPreferences;
+    policy: ManifestPolicy;
+    learning: Record<string, {
+        rate: number;
+        total: number;
+    }>;
+    setup: {
+        hasAnyProvider: boolean;
+        recommendedAction: string | null;
+        zeroProviderMode: boolean;
+    };
+    environment: {
+        mcpServers: string[];
+        claudePlugins: string[];
+        codexPlugins: string[];
+        shellSnapshots: number;
+        configuredHooks: Record<string, number>;
+        replitTools: {
+            available: boolean;
+            checkpoints: boolean;
+        };
+    };
+    timestamp: string;
+}
+interface ProviderManifestEntry {
+    available: boolean;
+    authenticated: boolean;
+    plan: string;
+    models: string[];
+    health: string;
+    budget: {
+        pressure5h: number;
+        pressure7d: number;
+    };
+    source: string;
+}
+interface ManifestPreferences {
+    bias: string;
+    forbiddenModels: string[];
+    preferredModels: string[];
+    costBias: number;
+    confirmBeforeExpensive: boolean;
+}
+interface ManifestPolicy {
+    highRiskRequiresBestAvailable: boolean;
+    failoverMode: string;
+    dualBrainThreshold: string;
+}
+export interface EffectivePolicyResult {
+    provider: string;
+    model: string;
+    tier: string;
+    reason: string;
+    overrides: string[];
+}
+interface OnboardingOptions {
+    interactive?: boolean;
+    cwd?: string;
+    global?: boolean;
+    rl?: ReadlineInterface;
+}
+interface SaveProfileOptions {
+    cwd?: string;
+    global?: boolean;
+}
+interface RememberPreferenceOptions {
+    scope?: string;
+    cwd?: string;
+    global?: boolean;
+}
+/**
+ * Write (or update) the dual_brain_preferences.md file in the Claude Code
+ * memory directory, and ensure MEMORY.md has an index entry for it.
+ * Fails silently if the memory directory is absent or unwritable.
+ */
+declare function syncPreferencesToMemory(profile: Profile, cwd?: string): void;
+/**
+ * Detect the runtime environment.
+ * Returns { isReplit, hasReplitTools, isCI }.
+ */
+declare function detectEnvironment(): EnvironmentInfo;
+/**
+ * Detect what providers and tools are actually available.
+ * Never makes network calls, never claims to know configured plan or price.
+ */
+declare function detectCapabilities(cwd?: string): Promise<DetectedCapabilities>;
+/**
+ * Generate an honest 2-3 line onboarding/status message based on
+ * what we can actually verify.
+ */
+declare function getOnboardingMessage(capabilities: DetectedCapabilities | null, workStyle?: string): string;
+declare function defaultProfile(): Profile;
+declare function loadProfile(cwd?: string): Profile;
+declare function saveProfile(profile: Profile, opts?: SaveProfileOptions): string;
+declare function runOnboarding(opts?: OnboardingOptions): Promise<Profile>;
+declare function ensureProfile(cwd?: string, opts?: OnboardingOptions): Promise<Profile>;
+declare function rememberPreference(text: string, opts?: RememberPreferenceOptions): Profile;
+declare function forgetPreference(text: string, cwd?: string): Profile;
+declare function getActivePreferences(cwd?: string): Preference[];
+interface ProviderEntry extends ProviderConfig {
+    name: string;
+}
+declare function getAvailableProviders(profile: Profile): ProviderEntry[];
+declare function isSoloBrain(profile: Profile): boolean;
+declare function getHeadModel(profile: Profile): string;
+/**
+ * Silently configure a profile from detected capabilities — no user input.
+ */
+declare function autoSetup(cwd?: string): Promise<AutoSetupResult>;
+/**
+ * Silently refresh the Claude OAuth token before it expires.
+ */
+declare function autoRefreshToken(cwd?: string): Promise<TokenRefreshResult>;
+/**
+ * Detect CLI login status for Claude and Codex.
+ * Checks config files on disk — never makes network calls.
+ */
+declare function detectAuth(): Promise<AuthDetectionResult>;
+/** @deprecated Use detectCapabilities() instead. */
+declare function detectExistingAuth(cwd?: string): Promise<Record<string, unknown>>;
+/** @deprecated Price-based plan tiers removed. Returns null for all providers. */
+declare function detectPlans(): Record<string, null>;
+/** @deprecated Plan tracking removed. Use provider enabled flag instead. */
+declare function saveSubscription(provider: string, config: unknown, cwd?: string): Profile;
+/** @deprecated Plan tracking removed. Use getAvailableProviders() instead. */
+declare function listSubscriptions(cwd?: string): Record<string, ProviderConfig>;
+export declare function loadCredentials(cwd?: string): CredentialStore;
+export declare function saveCredentials(data: CredentialStore, cwd?: string): string | undefined;
+export declare function addCredential(cred: Credential, cwd?: string): Credential;
+export declare function removeCredential(id: string, cwd?: string): void;
+export declare function getHealthyCredentials(provider?: string | null, cwd?: string): Credential[];
+export declare function checkCredentialHealth(cred: Credential, cwd?: string): Promise<Credential>;
+export declare function detectCredentials(cwd?: string): Promise<Credential[]>;
+export declare function getCredentialSummary(cwd?: string): {
+    total: number;
+    byProvider: Record<string, number>;
+    healthy: number;
+    degraded: number;
+    teamCapacity: string;
+};
+/**
+ * Build a normalized capability manifest that consolidates provider health,
+ * subscription config, user preferences, policy, and learning data.
+ */
+export declare function getCapabilityManifest(cwd?: string): Promise<CapabilityManifest>;
+/**
+ * Compute the effective routing policy for a specific task, applying rules in order:
+ * 1. Safety constraints (high-risk -> best available model)
+ * 2. Provider availability
+ * 3. Task tier fit (search->haiku, execute->sonnet, think->opus)
+ * 4. User preferences (cost bias, forbidden models)
+ * 5. Learning (prefer models with >=90% success rate for this task type)
+ */
+export declare function getEffectivePolicy(manifest: CapabilityManifest, taskContext?: {
+    tier?: string;
+    risk?: string;
+    taskType?: string;
+}): EffectivePolicyResult;
+export { loadProfile, saveProfile, ensureProfile, runOnboarding, rememberPreference, forgetPreference, getActivePreferences, getAvailableProviders, isSoloBrain, getHeadModel, detectCapabilities, getOnboardingMessage, syncPreferencesToMemory, detectAuth, detectEnvironment, autoSetup, autoRefreshToken, detectExistingAuth, detectPlans, saveSubscription, listSubscriptions, defaultProfile, };