@compilr-dev/cli 0.5.0 → 0.5.1

package/dist/models/ollama-models.js

@@ -0,0 +1,178 @@
+/**
+ * Ollama Model Auto-Detection
+ *
+ * Fetches available models from a running Ollama instance.
+ * Provides caching to avoid repeated API calls.
+ */
+import { getSetting } from '../settings/index.js';
+// =============================================================================
+// Cache
+// =============================================================================
+/** Cache duration in milliseconds (30 seconds) */
+const CACHE_DURATION_MS = 30_000;
+/** Cached result */
+let cachedResult = null;
+/**
+ * Clear the cache (useful for testing or forcing refresh).
+ */
+export function clearOllamaModelsCache() {
+    cachedResult = null;
+}
+// =============================================================================
+// Main Function
+// =============================================================================
+/**
+ * Get the Ollama base URL from settings or environment.
+ */
+function getOllamaBaseUrl() {
+    const settingUrl = getSetting('ollamaBaseUrl');
+    return (typeof settingUrl === 'string' ? settingUrl : null)
+        ?? process.env.OLLAMA_BASE_URL
+        ?? process.env.OLLAMA_HOST
+        ?? 'http://localhost:11434';
+}
+/**
+ * List all locally available Ollama models.
+ *
+ * Features:
+ * - Caches results for 30 seconds to avoid repeated API calls
+ * - Returns gracefully with error info when Ollama is not running
+ * - Parses model metadata (size, family, quantization)
+ *
+ * @param forceRefresh - If true, bypasses the cache
+ */
+export async function listOllamaModels(forceRefresh = false) {
+    // Check cache
+    if (!forceRefresh && cachedResult) {
+        const age = Date.now() - cachedResult.fetchedAt;
+        if (age < CACHE_DURATION_MS) {
+            return cachedResult;
+        }
+    }
+    const ollamaHost = getOllamaBaseUrl();
+    try {
+        const response = await fetch(`${ollamaHost}/api/tags`, {
+            method: 'GET',
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok) {
+            cachedResult = {
+                success: false,
+                models: [],
+                error: `Ollama returned status ${String(response.status)}`,
+                ollamaRunning: true, // Server responded, just with an error
+                fetchedAt: Date.now(),
+            };
+            return cachedResult;
+        }
+        const data = await response.json();
+        const models = (data.models ?? []).map(m => ({
+            name: m.name,
+            size: m.size,
+            modifiedAt: m.modified_at,
+            digest: m.digest,
+            details: m.details ? {
+                family: m.details.family,
+                parameterSize: m.details.parameter_size,
+                quantizationLevel: m.details.quantization_level,
+            } : undefined,
+        }));
+        // Sort by name for consistent display
+        models.sort((a, b) => a.name.localeCompare(b.name));
+        cachedResult = {
+            success: true,
+            models,
+            ollamaRunning: true,
+            fetchedAt: Date.now(),
+        };
+        return cachedResult;
+    }
+    catch (error) {
+        let errorMsg = 'Unknown error';
+        let ollamaRunning = false;
+        if (error instanceof Error) {
+            if (error.name === 'AbortError' || error.message.includes('timeout')) {
+                errorMsg = 'Connection timed out';
+                ollamaRunning = false;
+            }
+            else if (error.message.includes('ECONNREFUSED') || error.message.includes('fetch failed')) {
+                errorMsg = 'Ollama is not running. Start it with: ollama serve';
+                ollamaRunning = false;
+            }
+            else {
+                errorMsg = error.message;
+            }
+        }
+        cachedResult = {
+            success: false,
+            models: [],
+            error: errorMsg,
+            ollamaRunning,
+            fetchedAt: Date.now(),
+        };
+        return cachedResult;
+    }
+}
+// =============================================================================
+// Helper Functions
+// =============================================================================
+/**
+ * Check if a specific model is available locally.
+ * Uses the cached model list for efficiency.
+ */
+export async function isOllamaModelAvailable(modelId) {
+    const result = await listOllamaModels();
+    if (!result.success) {
+        return false;
+    }
+    const normalizedModelId = modelId.toLowerCase();
+    return result.models.some(m => {
+        const name = m.name.toLowerCase();
+        // Exact match or model without tag matches
+        return name === normalizedModelId ||
+            name.startsWith(normalizedModelId + ':') ||
+            normalizedModelId.startsWith(name.split(':')[0]);
+    });
+}
+/**
+ * Format model size for display (e.g., "4.1 GB").
+ */
+export function formatModelSize(bytes) {
+    if (bytes < 1024)
+        return `${String(bytes)} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+/**
+ * Get a friendly display name for a model.
+ * Capitalizes the base name and formats the tag.
+ */
+export function getOllamaModelDisplayName(name) {
+    const [baseName, tag] = name.split(':');
+    // Capitalize first letter of each word
+    const formattedBase = baseName
+        .split(/[-_]/)
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+    if (tag) {
+        return `${formattedBase} (${tag})`;
+    }
+    return formattedBase;
+}
+/**
+ * Get a short description for a model based on its metadata.
+ */
+export function getOllamaModelDescription(model) {
+    const parts = [];
+    if (model.details?.parameterSize) {
+        parts.push(model.details.parameterSize);
+    }
+    if (model.details?.quantizationLevel) {
+        parts.push(model.details.quantizationLevel);
+    }
+    parts.push(formatModelSize(model.size));
+    return parts.join(' · ');
+}

package/dist/models/provider-types.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Provider Type Definition
+ *
+ * Re-exported from @compilr-dev/sdk — single source of truth.
+ */
+export type { ProviderType } from '@compilr-dev/sdk';

package/dist/models/provider-types.js

@@ -0,0 +1 @@
+export {};

package/dist/models/providers.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Provider Metadata — CLI extension of SDK provider data
+ *
+ * Re-exports SDK types and data, extending ProviderMetadata with
+ * CLI-specific `credentialKey` for the encrypted credential store.
+ */
+import type { ProviderType } from './provider-types.js';
+import type { ProviderKey } from '../utils/credentials.js';
+import { type ProviderMetadata as SdkProviderMetadata } from '@compilr-dev/sdk';
+export { type OthersProviderModel, TOGETHER_MODELS, GROQ_MODELS, FIREWORKS_MODELS, PERPLEXITY_MODELS, OPENROUTER_MODELS, getModelsForOthersProvider, } from '@compilr-dev/sdk';
+/**
+ * CLI-extended provider metadata — adds credentialKey for encrypted storage.
+ */
+export interface ProviderMetadata extends SdkProviderMetadata {
+    /** Credential key for API key storage (CLI-specific) */
+    credentialKey: ProviderKey;
+}
+/**
+ * CLI-extended provider metadata registry.
+ * Merges SDK metadata with CLI credential keys.
+ */
+export declare const PROVIDER_METADATA: Record<ProviderType, ProviderMetadata>;
+/**
+ * Get provider metadata by type (CLI-extended with credentialKey).
+ */
+export declare function getProviderMetadata(provider: ProviderType): ProviderMetadata;
+/**
+ * Get all "Others" providers (for UI listing).
+ * Returns CLI-extended metadata with credentialKey.
+ */
+export declare function getOthersProviders(): ProviderMetadata[];
+/**
+ * Check if a provider is an "Others" provider.
+ */
+export declare function isOthersProvider(provider: ProviderType): boolean;

package/dist/models/providers.js

@@ -0,0 +1,58 @@
+/**
+ * Provider Metadata — CLI extension of SDK provider data
+ *
+ * Re-exports SDK types and data, extending ProviderMetadata with
+ * CLI-specific `credentialKey` for the encrypted credential store.
+ */
+import { PROVIDER_METADATA as SDK_PROVIDER_METADATA, } from '@compilr-dev/sdk';
+// Re-export SDK types that don't need CLI extensions
+export { TOGETHER_MODELS, GROQ_MODELS, FIREWORKS_MODELS, PERPLEXITY_MODELS, OPENROUTER_MODELS, getModelsForOthersProvider, } from '@compilr-dev/sdk';
+/**
+ * Credential key mapping: ProviderType → ProviderKey
+ */
+const CREDENTIAL_KEYS = {
+    claude: 'anthropic',
+    openai: 'openai',
+    gemini: 'google',
+    ollama: 'ollama',
+    together: 'together',
+    groq: 'groq',
+    fireworks: 'fireworks',
+    perplexity: 'perplexity',
+    openrouter: 'openrouter',
+    custom: 'openai', // Custom uses openai-compatible format by default
+};
+/**
+ * CLI-extended provider metadata registry.
+ * Merges SDK metadata with CLI credential keys.
+ */
+export const PROVIDER_METADATA = (() => {
+    const result = {};
+    for (const [key, sdkMeta] of Object.entries(SDK_PROVIDER_METADATA)) {
+        const providerType = key;
+        result[providerType] = {
+            ...sdkMeta,
+            credentialKey: CREDENTIAL_KEYS[providerType],
+        };
+    }
+    return result;
+})();
+/**
+ * Get provider metadata by type (CLI-extended with credentialKey).
+ */
+export function getProviderMetadata(provider) {
+    return PROVIDER_METADATA[provider];
+}
+/**
+ * Get all "Others" providers (for UI listing).
+ * Returns CLI-extended metadata with credentialKey.
+ */
+export function getOthersProviders() {
+    return Object.values(PROVIDER_METADATA).filter(p => p.category === 'others' && p.type !== 'custom');
+}
+/**
+ * Check if a provider is an "Others" provider.
+ */
+export function isOthersProvider(provider) {
+    return PROVIDER_METADATA[provider].category === 'others';
+}

package/dist/models/types.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Model Types — Re-exported from @compilr-dev/sdk
+ */
+export { type ModelTier, type TierInfo, type ProviderModelMap, MODEL_TIERS, TIER_INFO, isValidTier, } from '@compilr-dev/sdk';

package/dist/models/types.js

@@ -0,0 +1,4 @@
+/**
+ * Model Types — Re-exported from @compilr-dev/sdk
+ */
+export { MODEL_TIERS, TIER_INFO, isValidTier, } from '@compilr-dev/sdk';

package/dist/multi-agent/activity.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Activity Recording Module
+ *
+ * Provides a global function for tools to record team activity.
+ * The SharedContextManager is set by the REPL when a team is active.
+ */
+import type { SharedContextManager, TeamActivityType } from './shared-context.js';
+/**
+ * Set the active SharedContextManager for activity recording
+ * Called by the REPL when a team is initialized
+ */
+export declare function setActiveSharedContext(ctx: SharedContextManager | null): void;
+/**
+ * Get the active SharedContextManager
+ */
+export declare function getActiveSharedContext(): SharedContextManager | null;
+/**
+ * Record team activity
+ * Safe to call even if no team is active (will be a no-op)
+ */
+export declare function recordTeamActivity(agentId: string, action: TeamActivityType, summary: string): void;

package/dist/multi-agent/activity.js

@@ -0,0 +1,34 @@
+/**
+ * Activity Recording Module
+ *
+ * Provides a global function for tools to record team activity.
+ * The SharedContextManager is set by the REPL when a team is active.
+ */
+// Module-level reference to the active SharedContextManager
+let activeSharedContext = null;
+/**
+ * Set the active SharedContextManager for activity recording
+ * Called by the REPL when a team is initialized
+ */
+export function setActiveSharedContext(ctx) {
+    activeSharedContext = ctx;
+}
+/**
+ * Get the active SharedContextManager
+ */
+export function getActiveSharedContext() {
+    return activeSharedContext;
+}
+/**
+ * Record team activity
+ * Safe to call even if no team is active (will be a no-op)
+ */
+export function recordTeamActivity(agentId, action, summary) {
+    if (activeSharedContext) {
+        activeSharedContext.recordActivity({
+            agentId,
+            action,
+            summary,
+        });
+    }
+}

package/dist/multi-agent/agent-selection.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Agent Selection Helpers
+ *
+ * Provides functions for selecting the best agent for a task:
+ * - findAgentForRole: Find an agent by role (LRU selection if multiple)
+ * - findAgentById: Find an agent by ID
+ * - getAvailableSpecialists: Get all non-default agents
+ *
+ * Uses Least Recently Used (LRU) selection when multiple agents have the same role.
+ * This spreads work across agents and prepares for future background execution
+ * where we'll prefer idle agents.
+ */
+import type { AgentTeam } from './team.js';
+import type { TeamAgent } from './team-agent.js';
+import type { AgentRole } from './types.js';
+/**
+ * Find the best agent for a given role.
+ * If multiple agents have the same role, selects the least recently used.
+ *
+ * @param team - The agent team
+ * @param role - The role to find (e.g., 'arch', 'dev', 'qa')
+ * @returns The best matching agent, or null if none found
+ */
+export declare function findAgentForRole(team: AgentTeam, role: AgentRole): TeamAgent | null;
+/**
+ * Find an agent by ID.
+ *
+ * @param team - The agent team
+ * @param id - The agent ID (e.g., 'arch', 'dev-1', 'my-custom-agent')
+ * @returns The agent, or null if not found
+ */
+export declare function findAgentById(team: AgentTeam, id: string): TeamAgent | null;
+/**
+ * Get all specialist agents (non-default agents).
+ * Useful for listing available delegation targets.
+ *
+ * @param team - The agent team
+ * @returns Array of specialist agents
+ */
+export declare function getAvailableSpecialists(team: AgentTeam): TeamAgent[];
+/**
+ * Get a summary of available specialists for the coordinator.
+ * Returns a formatted string listing specialists by role.
+ *
+ * @param team - The agent team
+ * @returns Formatted string of available specialists
+ */
+export declare function getSpecialistsSummary(team: AgentTeam): string;
+/**
+ * Check if the team has any specialists available for delegation.
+ *
+ * @param team - The agent team
+ * @returns True if there are specialist agents
+ */
+export declare function hasSpecialists(team: AgentTeam): boolean;

package/dist/multi-agent/agent-selection.js

@@ -0,0 +1,90 @@
+/**
+ * Agent Selection Helpers
+ *
+ * Provides functions for selecting the best agent for a task:
+ * - findAgentForRole: Find an agent by role (LRU selection if multiple)
+ * - findAgentById: Find an agent by ID
+ * - getAvailableSpecialists: Get all non-default agents
+ *
+ * Uses Least Recently Used (LRU) selection when multiple agents have the same role.
+ * This spreads work across agents and prepares for future background execution
+ * where we'll prefer idle agents.
+ */
+/**
+ * Find the best agent for a given role.
+ * If multiple agents have the same role, selects the least recently used.
+ *
+ * @param team - The agent team
+ * @param role - The role to find (e.g., 'arch', 'dev', 'qa')
+ * @returns The best matching agent, or null if none found
+ */
+export function findAgentForRole(team, role) {
+    const agents = team.getAll();
+    // Filter to agents with matching role
+    const candidates = agents.filter((agent) => agent.role === role);
+    if (candidates.length === 0) {
+        return null;
+    }
+    if (candidates.length === 1) {
+        return candidates[0];
+    }
+    // Multiple candidates: select Least Recently Used (LRU)
+    // Sort by lastActivity ascending (oldest first)
+    candidates.sort((a, b) => a.lastActivity.getTime() - b.lastActivity.getTime());
+    return candidates[0];
+}
+/**
+ * Find an agent by ID.
+ *
+ * @param team - The agent team
+ * @param id - The agent ID (e.g., 'arch', 'dev-1', 'my-custom-agent')
+ * @returns The agent, or null if not found
+ */
+export function findAgentById(team, id) {
+    return team.get(id) ?? null;
+}
+/**
+ * Get all specialist agents (non-default agents).
+ * Useful for listing available delegation targets.
+ *
+ * @param team - The agent team
+ * @returns Array of specialist agents
+ */
+export function getAvailableSpecialists(team) {
+    return team.getAll().filter((agent) => agent.id !== 'default');
+}
+/**
+ * Get a summary of available specialists for the coordinator.
+ * Returns a formatted string listing specialists by role.
+ *
+ * @param team - The agent team
+ * @returns Formatted string of available specialists
+ */
+export function getSpecialistsSummary(team) {
+    const specialists = getAvailableSpecialists(team);
+    if (specialists.length === 0) {
+        return 'No specialist agents available. Add agents via /team.';
+    }
+    // Group by role
+    const byRole = new Map();
+    for (const agent of specialists) {
+        const list = byRole.get(agent.role) ?? [];
+        list.push(agent);
+        byRole.set(agent.role, list);
+    }
+    const lines = [];
+    for (const [role, agents] of byRole) {
+        const agentList = agents.map((a) => `$${a.id}`).join(', ');
+        lines.push(`- ${role}: ${agentList}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Check if the team has any specialists available for delegation.
+ *
+ * @param team - The agent team
+ * @returns True if there are specialist agents
+ */
+export function hasSpecialists(team) {
+    return getAvailableSpecialists(team).length > 0;
+}

package/dist/multi-agent/artifacts.d.ts

@@ -0,0 +1,197 @@
+/**
+ * ArtifactStore - Storage for team artifacts
+ *
+ * Artifacts are named pieces of work that agents can publish and reference:
+ * - design: Architecture, API specs, data models
+ * - plan: Sprint plans, task breakdowns, timelines
+ * - review: Code reviews, security audits, feedback
+ * - decision: Architectural decisions, trade-off analysis
+ * - note: General notes, meeting summaries
+ */
+/**
+ * Artifact types
+ */
+export type ArtifactType = 'design' | 'plan' | 'review' | 'decision' | 'note';
+/**
+ * Full artifact structure
+ */
+export interface Artifact {
+    id: string;
+    name: string;
+    agent: string;
+    type: ArtifactType;
+    content: string;
+    summary: string;
+    version: number;
+    createdAt: Date;
+    updatedAt: Date;
+    mentions: string[];
+    referencedBy: string[];
+}
+/**
+ * Artifact summary for the shared context index
+ */
+export interface ArtifactSummary {
+    id: string;
+    name: string;
+    agent: string;
+    type: ArtifactType;
+    summary: string;
+    updatedAt: Date;
+}
+/**
+ * Options for creating an artifact
+ */
+export interface CreateArtifactOptions {
+    name: string;
+    agent: string;
+    type: ArtifactType;
+    content: string;
+    summary?: string;
+}
+/**
+ * Options for updating an artifact
+ */
+export interface UpdateArtifactOptions {
+    content?: string;
+    summary?: string;
+    type?: ArtifactType;
+}
+/**
+ * Serialized artifact for persistence
+ */
+export interface SerializedArtifact {
+    id: string;
+    name: string;
+    agent: string;
+    type: ArtifactType;
+    content: string;
+    summary: string;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+    mentions?: string[];
+    referencedBy?: string[];
+}
+/**
+ * Artifact index for persistence
+ */
+export interface ArtifactIndex {
+    version: number;
+    artifacts: Array<{
+        id: string;
+        name: string;
+        agent: string;
+        type: ArtifactType;
+        summary: string;
+        updatedAt: string;
+    }>;
+    updatedAt: string;
+}
+/**
+ * Manages artifact storage and retrieval
+ */
+export declare class ArtifactStore {
+    private readonly basePath;
+    private readonly artifacts;
+    private readonly nameToId;
+    private updatedAt;
+    constructor(basePath: string);
+    /**
+     * Get the artifacts directory path
+     */
+    private getArtifactsDir;
+    /**
+     * Get the index file path
+     */
+    private getIndexPath;
+    /**
+     * Get the path for an artifact file
+     */
+    private getArtifactPath;
+    /**
+     * Ensure artifacts directory exists
+     */
+    private ensureDir;
+    /**
+     * Create a new artifact
+     */
+    create(options: CreateArtifactOptions): Artifact;
+    /**
+     * Get an artifact by ID
+     */
+    get(id: string): Artifact | undefined;
+    /**
+     * Get an artifact by name (case-insensitive)
+     */
+    getByName(name: string): Artifact | undefined;
+    /**
+     * Update an artifact
+     */
+    update(id: string, options: UpdateArtifactOptions): Artifact | undefined;
+    /**
+     * Delete an artifact
+     */
+    delete(id: string): boolean;
+    /**
+     * Rename an artifact
+     */
+    rename(id: string, newName: string): Artifact | undefined;
+    /**
+     * List all artifacts
+     */
+    list(): Artifact[];
+    /**
+     * List artifacts by agent
+     */
+    listByAgent(agent: string): Artifact[];
+    /**
+     * List artifacts by type
+     */
+    listByType(type: ArtifactType): Artifact[];
+    /**
+     * Search artifacts by name or content
+     */
+    search(query: string): Artifact[];
+    /**
+     * Get artifact count
+     */
+    get size(): number;
+    /**
+     * Check if an artifact exists by name
+     */
+    has(name: string): boolean;
+    /**
+     * Check if an artifact exists by ID
+     */
+    hasId(id: string): boolean;
+    /**
+     * Generate a summary from content
+     * Simple extraction of first meaningful lines
+     */
+    private generateSummary;
+    /**
+     * Get summaries for shared context injection
+     */
+    getSummaries(): ArtifactSummary[];
+    /**
+     * Save all artifacts to disk
+     */
+    save(): void;
+    /**
+     * Save just the index file
+     */
+    private saveIndex;
+    /**
+     * Load artifacts from disk
+     */
+    load(): void;
+    /**
+     * Clear all artifacts (including from disk)
+     */
+    clear(): void;
+    /**
+     * Get the last update timestamp
+     */
+    getLastUpdated(): Date;
+}