@stan-chen/simple-cli 0.2.1

package/dist/registry.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Tool Registry: Auto-imports tools from src/tools/, skills/, and scripts/
+ * Supports built-in tools, MCP tools, and project-specific custom tools
+ */
+import { z } from 'zod';
+export type Permission = 'read' | 'write' | 'execute';
+export interface Tool {
+    name: string;
+    description: string;
+    permission: Permission;
+    inputSchema: z.ZodType;
+    execute: (args: Record<string, unknown>) => Promise<unknown>;
+    source?: 'builtin' | 'mcp' | 'project';
+    serverName?: string;
+    specification?: string;
+}
+export type { Tool as ToolModule };
+export declare const loadTools: () => Promise<Map<string, Tool>>;
+export declare const loadAllTools: () => Promise<Map<string, Tool>>;
+export declare const getToolDefinitions: (tools: Map<string, Tool>) => string;
+export declare const validateToolArgs: (tool: Tool, args: unknown) => {
+    valid: boolean;
+    error?: string;
+};

package/dist/registry.js

@@ -0,0 +1,379 @@
+/**
+ * Tool Registry: Auto-imports tools from src/tools/, skills/, and scripts/
+ * Supports built-in tools, MCP tools, and project-specific custom tools
+ */
+import { readdir, readFile, stat } from 'fs/promises';
+import { spawn } from 'child_process';
+import { join, dirname, basename, extname } from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { z } from 'zod';
+import { getMCPManager } from './mcp/manager.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TOOLS_DIR = join(__dirname, 'tools');
+/**
+ * Extract documentation from the beginning of a file (comments)
+ */
+function extractDocFromComments(content) {
+    const lines = content.split('\n');
+    let doc = '';
+    let inDoc = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('/**') || trimmed.startsWith('"""')) {
+            inDoc = true;
+            continue;
+        }
+        if (inDoc && (trimmed.endsWith('*/') || trimmed.endsWith('"""'))) {
+            inDoc = false;
+            break;
+        }
+        if (inDoc) {
+            doc += trimmed.replace(/^\* ?/, '') + '\n';
+        }
+        else if (trimmed.startsWith('//') || trimmed.startsWith('#')) {
+            doc += trimmed.replace(/^(\/\/|#) ?/, '') + '\n';
+        }
+        else if (trimmed && !trimmed.startsWith('import') && !trimmed.startsWith('from')) {
+            break;
+        }
+    }
+    return doc.trim();
+}
+/**
+ * Parses a tool definition from a Markdown file (.md) or string
+ */
+function parseMarkdownTool(content, filename) {
+    const lines = content.split('\n');
+    const meta = {
+        name: basename(filename, extname(filename)),
+        description: '',
+        command: '',
+        parameters: {},
+        permission: 'execute'
+    };
+    let currentSection = '';
+    for (const line of lines) {
+        if (line.startsWith('# ')) {
+            meta.name = line.replace('# ', '').trim();
+        }
+        else if (line.startsWith('## ')) {
+            currentSection = line.replace('## ', '').trim().toLowerCase();
+        }
+        else if (currentSection === 'command' && line.trim()) {
+            meta.command = line.trim();
+        }
+        else if (currentSection === 'parameters' && line.trim().startsWith('- ')) {
+            const match = line.match(/- (\w+): (\w+)(?: - (.+))?/);
+            if (match) {
+                meta.parameters[match[1]] = { type: match[2], description: match[3] || '' };
+            }
+        }
+        else if (!currentSection && line.trim() && !line.startsWith('#')) {
+            meta.description += line.trim() + ' ';
+        }
+    }
+    meta.description = meta.description.trim();
+    return meta;
+}
+// Helper to create a Tool from metadata (JSON or MD)
+function createScriptTool(meta, source, spec) {
+    return {
+        name: meta.name,
+        description: meta.description || `Script tool: ${meta.command}`,
+        permission: meta.permission || 'execute',
+        inputSchema: z.object({}).passthrough(), // Flexible schema for scripts
+        source,
+        specification: spec,
+        execute: async (args) => {
+            return new Promise((resolve, reject) => {
+                let finalCommand = meta.command;
+                const isWindows = process.platform === 'win32';
+                if (isWindows && finalCommand.endsWith('.ps1')) {
+                    finalCommand = `powershell -ExecutionPolicy Bypass -File ${finalCommand}`;
+                }
+                const child = spawn(finalCommand, {
+                    shell: true,
+                    cwd: process.cwd(),
+                    env: { ...process.env, TOOL_INPUT: JSON.stringify(args) },
+                });
+                let stdout = '';
+                let stderr = '';
+                child.stdout?.on('data', (data) => stdout += data.toString());
+                child.stderr?.on('data', (data) => stderr += data.toString());
+                child.on('close', (code) => {
+                    if (code === 0)
+                        resolve(stdout.trim());
+                    else
+                        reject(new Error(`Exit ${code}: ${stderr.trim()}`));
+                });
+                child.stdin?.write(JSON.stringify(args));
+                child.stdin?.end();
+            });
+        }
+    };
+}
+/**
+ * Recursively search for a documentation file (.md or .json) for a given tool name
+ */
+async function findDocInDir(dir, baseName) {
+    const files = await readdir(dir);
+    for (const f of files) {
+        if (basename(f, extname(f)) === baseName && (f.endsWith('.md') || f.endsWith('.json') || f.endsWith('.txt'))) {
+            const content = await readFile(join(dir, f), 'utf-8');
+            return { content, file: f };
+        }
+    }
+    return null;
+}
+// Helper to load tools from a specific directory (recursive)
+async function loadToolsFromDir(dir, source) {
+    const tools = new Map();
+    try {
+        const items = await readdir(dir);
+        for (const item of items) {
+            const fullPath = join(dir, item);
+            const s = await stat(fullPath);
+            if (s.isDirectory()) {
+                // Recursive call for subdirectories
+                const subTools = await loadToolsFromDir(fullPath, source);
+                for (const [name, tool] of subTools) {
+                    tools.set(name, tool);
+                }
+                // Special case: Folder named ' heavy_lifting' might have 'heavy_lifting.md' inside it
+                if (!tools.has(item)) {
+                    const doc = await findDocInDir(fullPath, item);
+                    if (doc && doc.file.endsWith('.md')) {
+                        const meta = parseMarkdownTool(doc.content, doc.file);
+                        if (meta && meta.command) {
+                            tools.set(meta.name, createScriptTool(meta, source, doc.content));
+                        }
+                    }
+                }
+                continue;
+            }
+            const ext = extname(item);
+            const base = basename(item, ext);
+            // 1. Native Node tools
+            if (ext === '.ts' || ext === '.js' || ext === '.mjs') {
+                if (item.includes('.test.'))
+                    continue;
+                try {
+                    const module = await import(pathToFileURL(fullPath).href);
+                    const toolDef = module.tool || module;
+                    if (toolDef.name && toolDef.execute) {
+                        const schema = toolDef.inputSchema || toolDef.schema;
+                        tools.set(toolDef.name, {
+                            name: toolDef.name,
+                            description: toolDef.description || 'No description',
+                            permission: toolDef.permission || 'read',
+                            inputSchema: schema || z.object({}),
+                            execute: toolDef.execute,
+                            source,
+                        });
+                        continue;
+                    }
+                }
+                catch { /* might be a script, fall through */ }
+            }
+            // 2. Generic Script with internal docs or companion meta file
+            if (ext !== '.md' && ext !== '.txt' && ext !== '.json') {
+                try {
+                    const content = await readFile(fullPath, 'utf-8');
+                    const internalDoc = extractDocFromComments(content);
+                    // Check for companion meta file in the SAME directory
+                    const companion = await findDocInDir(dir, base);
+                    let meta = null;
+                    let specContent = internalDoc;
+                    if (companion) {
+                        if (companion.file.endsWith('.json')) {
+                            meta = JSON.parse(companion.content);
+                        }
+                        else {
+                            meta = parseMarkdownTool(companion.content, companion.file);
+                            specContent = companion.content;
+                        }
+                    }
+                    else if (internalDoc) {
+                        meta = parseMarkdownTool(internalDoc, item);
+                        if (!meta.command) {
+                            if (ext === '.py')
+                                meta.command = `python ${fullPath}`;
+                            else if (ext === '.sh')
+                                meta.command = `bash ${fullPath}`;
+                            else if (ext === '.ps1')
+                                meta.command = `powershell ${fullPath}`;
+                            else
+                                meta.command = fullPath;
+                        }
+                    }
+                    if (meta && meta.name && meta.command) {
+                        tools.set(meta.name, createScriptTool(meta, source, specContent));
+                    }
+                }
+                catch { /* skip errors */ }
+            }
+            // 3. Standalone Meta/Documentation Tools
+            if (ext === '.json' || ext === '.md' || ext === '.txt') {
+                if (Array.from(tools.values()).some(t => t.name === base))
+                    continue;
+                try {
+                    const content = await readFile(fullPath, 'utf-8');
+                    let meta = null;
+                    if (ext === '.json') {
+                        meta = JSON.parse(content);
+                    }
+                    else {
+                        meta = parseMarkdownTool(content, item);
+                    }
+                    if (meta && meta.name && meta.command) {
+                        tools.set(meta.name, createScriptTool(meta, source, content));
+                    }
+                }
+                catch { /* skip */ }
+            }
+        }
+    }
+    catch (error) {
+        // Directory might not exist
+    }
+    return tools;
+}
+// Load all tools from the tools directory
+export const loadTools = async () => {
+    const customDirs = ['skills', 'scripts', 'tools', '.simple-cli/tools'];
+    const builtinTools = await loadToolsFromDir(TOOLS_DIR, 'builtin');
+    const allProjectTools = new Map();
+    for (const d of customDirs) {
+        const dirPath = join(process.cwd(), d);
+        const tools = await loadToolsFromDir(dirPath, 'project');
+        for (const [name, tool] of tools) {
+            allProjectTools.set(name, tool);
+        }
+    }
+    return new Map([...builtinTools, ...allProjectTools]);
+};
+// Load MCP tools and merge with built-in tools
+export const loadAllTools = async () => {
+    const tools = await loadTools();
+    try {
+        const mcpManager = getMCPManager();
+        const mcpTools = mcpManager.getAllTools();
+        for (const mcpTool of mcpTools) {
+            const toolName = `mcp_${mcpTool.serverName}_${mcpTool.name}`;
+            tools.set(toolName, {
+                name: toolName,
+                description: mcpTool.description,
+                permission: 'execute',
+                inputSchema: z.object(mcpTool.inputSchema).passthrough(),
+                execute: mcpTool.execute,
+                source: 'mcp',
+                serverName: mcpTool.serverName,
+            });
+        }
+    }
+    catch {
+        // MCP not configured, skip
+    }
+    return tools;
+};
+// Get tool definitions for LLM prompt
+export const getToolDefinitions = (tools) => {
+    const sections = [];
+    const builtinTools = [];
+    const projectTools = [];
+    const mcpTools = [];
+    for (const tool of tools.values()) {
+        if (tool.source === 'mcp') {
+            mcpTools.push(tool);
+        }
+        else if (tool.source === 'project') {
+            projectTools.push(tool);
+        }
+        else {
+            builtinTools.push(tool);
+        }
+    }
+    if (builtinTools.length > 0) {
+        sections.push('## Built-in Tools\n');
+        for (const tool of builtinTools) {
+            sections.push(formatToolDefinition(tool));
+        }
+    }
+    if (projectTools.length > 0) {
+        sections.push('\n## Project Skills (Custom Tools)\n');
+        for (const tool of projectTools) {
+            sections.push(formatToolDefinition(tool));
+        }
+    }
+    if (mcpTools.length > 0) {
+        sections.push('\n## MCP Tools\n');
+        for (const tool of mcpTools) {
+            sections.push(formatToolDefinition(tool));
+        }
+    }
+    return sections.join('\n');
+};
+// Format a single tool definition
+function formatToolDefinition(tool) {
+    const lines = [
+        `### ${tool.name}`,
+        tool.description,
+        `Permission: ${tool.permission}`,
+    ];
+    if (tool.serverName) {
+        lines.push(`Server: ${tool.serverName}`);
+    }
+    // Extract parameters from schema
+    if (tool.inputSchema && 'shape' in tool.inputSchema) {
+        const shape = tool.inputSchema.shape;
+        const params = Object.entries(shape)
+            .map(([key, value]) => {
+            const zodType = value;
+            const description = zodType.description || '';
+            const typeName = getTypeName(zodType);
+            const optional = zodType.isOptional() ? '?' : '';
+            return `  - ${key}${optional}: ${typeName}${description ? ` - ${description}` : ''}`;
+        })
+            .join('\n');
+        if (params) {
+            lines.push('Parameters:');
+            lines.push(params);
+        }
+    }
+    return lines.join('\n') + '\n';
+}
+// Get human-readable type name from Zod type
+function getTypeName(zodType) {
+    const def = zodType._def;
+    if (def.typeName === 'ZodString')
+        return 'string';
+    if (def.typeName === 'ZodNumber')
+        return 'number';
+    if (def.typeName === 'ZodBoolean')
+        return 'boolean';
+    if (def.typeName === 'ZodArray')
+        return 'array';
+    if (def.typeName === 'ZodObject')
+        return 'object';
+    if (def.typeName === 'ZodEnum')
+        return `enum(${def.values.join('|')})`;
+    if (def.typeName === 'ZodOptional')
+        return getTypeName(def.innerType);
+    if (def.typeName === 'ZodDefault')
+        return getTypeName(def.innerType);
+    return def.typeName?.replace('Zod', '').toLowerCase() || 'unknown';
+}
+// Validate tool arguments
+export const validateToolArgs = (tool, args) => {
+    try {
+        tool.inputSchema.parse(args);
+        return { valid: true };
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            const messages = error.errors.map(e => `${e.path.join('.')}: ${e.message}`);
+            return { valid: false, error: messages.join('; ') };
+        }
+        return { valid: false, error: String(error) };
+    }
+};

package/dist/repoMap.d.ts

@@ -0,0 +1,5 @@
+/**
+ * RepoMap: Symbol-aware context generation
+ * Uses ts-morph for TypeScript/JavaScript and simple parsing for others.
+ */
+export declare const generateRepoMap: (rootDir?: string) => Promise<string>;

package/dist/repoMap.js

@@ -0,0 +1,79 @@
+/**
+ * RepoMap: Symbol-aware context generation
+ * Uses ts-morph for TypeScript/JavaScript and simple parsing for others.
+ */
+import { Project, ScriptTarget } from 'ts-morph';
+import { readdir } from 'fs/promises';
+import { join, extname, relative } from 'path';
+const IGNORED_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', 'coverage']);
+const TS_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx']);
+export const generateRepoMap = async (rootDir = '.') => {
+    const fileMaps = [];
+    // Initialize ts-morph project
+    const project = new Project({
+        compilerOptions: { target: ScriptTarget.ESNext, allowJs: true },
+        skipAddingFilesFromTsConfig: true,
+        useInMemoryFileSystem: true // Don't actually load files until we say so
+    });
+    const stack = [rootDir];
+    const validFiles = [];
+    // 1. Walk directory to find files
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        try {
+            const entries = await readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (IGNORED_DIRS.has(entry.name))
+                    continue;
+                const fullPath = join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    stack.push(fullPath);
+                }
+                else if (entry.isFile()) {
+                    validFiles.push(fullPath);
+                }
+            }
+        }
+        catch { /* ignore access errors */ }
+    }
+    // 2. Process Files
+    // Limit to 50 files for now to avoid context explosion
+    const filesToProcess = validFiles.slice(0, 50);
+    for (const filePath of filesToProcess) {
+        const ext = extname(filePath);
+        const relPath = relative(rootDir, filePath);
+        if (TS_EXTENSIONS.has(ext)) {
+            try {
+                // Use ts-morph
+                const sourceFile = project.createSourceFile(filePath, await import('fs/promises').then(fs => fs.readFile(filePath, 'utf-8')), { overwrite: true });
+                const symbols = [];
+                sourceFile.getClasses().forEach(c => symbols.push(`class ${c.getName()}`));
+                sourceFile.getFunctions().forEach(f => symbols.push(`func ${f.getName()}`));
+                sourceFile.getInterfaces().forEach(i => symbols.push(`interface ${i.getName()}`));
+                sourceFile.getTypeAliases().forEach(t => symbols.push(`type ${t.getName()}`));
+                sourceFile.getVariableStatements().forEach(v => {
+                    v.getDeclarations().forEach(d => symbols.push(`const ${d.getName()}`));
+                });
+                if (symbols.length > 0) {
+                    fileMaps.push({ path: relPath, symbols });
+                }
+            }
+            catch (e) {
+                // Fallback or ignore
+            }
+        }
+        else {
+            // Simple listing for non-TS files? Or just skip symbols to keep it clean.
+            // For now, let's just list the file path for completeness if it's source code
+            fileMaps.push({ path: relPath, symbols: [] });
+        }
+    }
+    if (fileMaps.length === 0)
+        return 'No source files found.';
+    return fileMaps.map(fm => {
+        if (fm.symbols.length === 0)
+            return `📄 ${fm.path}`;
+        const syms = fm.symbols.map(s => `    ${s}`).join('\n');
+        return `📄 ${fm.path}\n${syms}`;
+    }).join('\n\n');
+};

package/dist/router.d.ts

@@ -0,0 +1,41 @@
+/**
+ * MoE Router: Mix of Experts task routing
+ * Routes tasks to appropriate model tiers based on complexity
+ */
+import { z } from 'zod';
+export type Tier = 1 | 2 | 3 | 4 | 5;
+export interface TierConfig {
+    tier: Tier;
+    role: string;
+    model: string;
+    provider: 'openai' | 'anthropic' | 'gemini';
+}
+export interface RoutingDecision {
+    tier: Tier;
+    complexity: number;
+    contextRequired: 'high' | 'low';
+    risk: 'high' | 'low';
+    reasoning: string;
+}
+export declare const RoutingResponseSchema: z.ZodObject<{
+    complexity: z.ZodNumber;
+    contextRequired: z.ZodEnum<["high", "low"]>;
+    risk: z.ZodEnum<["high", "low"]>;
+    recommendedTier: z.ZodNumber;
+    reasoning: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    complexity: number;
+    contextRequired: "high" | "low";
+    risk: "high" | "low";
+    recommendedTier: number;
+    reasoning: string;
+}, {
+    complexity: number;
+    contextRequired: "high" | "low";
+    risk: "high" | "low";
+    recommendedTier: number;
+    reasoning: string;
+}>;
+export declare const loadTierConfig: () => Map<Tier, TierConfig>;
+export declare const routeTask: (task: string, orchestratorCall: (prompt: string) => Promise<string>) => Promise<RoutingDecision>;
+export declare const formatRoutingDecision: (decision: RoutingDecision, tiers: Map<Tier, TierConfig>) => string;

package/dist/router.js

@@ -0,0 +1,108 @@
+/**
+ * MoE Router: Mix of Experts task routing
+ * Routes tasks to appropriate model tiers based on complexity
+ */
+import { z } from 'zod';
+// Schema for Orchestrator's routing response
+export const RoutingResponseSchema = z.object({
+    complexity: z.number().min(1).max(10),
+    contextRequired: z.enum(['high', 'low']),
+    risk: z.enum(['high', 'low']),
+    recommendedTier: z.number().min(1).max(5),
+    reasoning: z.string()
+});
+// Default tier configurations
+const DEFAULT_TIERS = {
+    1: { role: 'Orchestrator / Architect', defaultModel: 'gpt-5.2-pro' },
+    2: { role: 'Senior Engineer', defaultModel: 'gpt-5.2-codex' },
+    3: { role: 'Junior Engineer', defaultModel: 'gpt-5-mini' },
+    4: { role: 'Intern / Linter', defaultModel: 'gpt-5-nano' },
+    5: { role: 'Safety / Utility', defaultModel: 'gemini-2.5-flash' }
+};
+// Load tier configuration from environment
+export const loadTierConfig = () => {
+    const tiers = new Map();
+    for (const tier of [1, 2, 3, 4, 5]) {
+        const envModel = process.env[`MOE_TIER_${tier}_MODEL`];
+        const model = envModel || DEFAULT_TIERS[tier].defaultModel;
+        // LiteLLM auto-detects provider from model name prefix (e.g., "anthropic/claude-3", "gemini/gemini-pro")
+        // For OpenAI models without prefix, it defaults to OpenAI
+        const provider = model.includes('/') ? model.split('/')[0] : 'openai';
+        tiers.set(tier, {
+            tier,
+            role: DEFAULT_TIERS[tier].role,
+            model,
+            provider
+        });
+    }
+    return tiers;
+};
+// Routing prompt template
+const ROUTING_PROMPT = `You are a task router for an AI coding assistant. Analyze the following task and determine its complexity.
+
+Respond ONLY with valid JSON in this exact format:
+{
+  "complexity": <1-10>,
+  "contextRequired": "<high|low>",
+  "risk": "<high|low>",
+  "recommendedTier": <1-5>,
+  "reasoning": "<brief explanation>"
+}
+
+Tier Guidelines:
+- Tier 1: Complex architecture, critical decisions, multi-system refactoring
+- Tier 2: Feature implementation, significant code changes, debugging complex issues
+- Tier 3: Routine tasks, unit tests, boilerplate code, simple features
+- Tier 4: Typo fixes, formatting, simple imports, trivial changes
+- Tier 5: Basic text operations, summaries
+
+Task to analyze:
+`;
+// Determine routing using Tier 1 orchestrator
+export const routeTask = async (task, orchestratorCall) => {
+    try {
+        const response = await orchestratorCall(ROUTING_PROMPT + task);
+        // Extract JSON from response
+        const jsonMatch = response.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            return getDefaultRouting(task);
+        }
+        const parsed = RoutingResponseSchema.parse(JSON.parse(jsonMatch[0]));
+        return {
+            tier: parsed.recommendedTier,
+            complexity: parsed.complexity,
+            contextRequired: parsed.contextRequired,
+            risk: parsed.risk,
+            reasoning: parsed.reasoning
+        };
+    }
+    catch (error) {
+        console.error('Routing error, using default:', error);
+        return getDefaultRouting(task);
+    }
+};
+// Fallback routing based on simple heuristics
+const getDefaultRouting = (task) => {
+    const taskLower = task.toLowerCase();
+    // Simple keyword-based routing
+    if (taskLower.match(/refactor|architect|design|migrate|security|auth/)) {
+        return { tier: 2, complexity: 7, contextRequired: 'high', risk: 'high', reasoning: 'Complex task keywords detected' };
+    }
+    if (taskLower.match(/implement|feature|add|create|build|debug/)) {
+        return { tier: 2, complexity: 6, contextRequired: 'high', risk: 'low', reasoning: 'Implementation task detected' };
+    }
+    if (taskLower.match(/test|boilerplate|template|simple/)) {
+        return { tier: 3, complexity: 4, contextRequired: 'low', risk: 'low', reasoning: 'Routine task detected' };
+    }
+    if (taskLower.match(/typo|fix|format|import|rename/)) {
+        return { tier: 4, complexity: 2, contextRequired: 'low', risk: 'low', reasoning: 'Minor task detected' };
+    }
+    // Default to Tier 3
+    return { tier: 3, complexity: 5, contextRequired: 'low', risk: 'low', reasoning: 'Default routing' };
+};
+// Format routing decision for logging
+export const formatRoutingDecision = (decision, tiers) => {
+    const tierConfig = tiers.get(decision.tier);
+    return `[Router] Tier ${decision.tier} (${tierConfig?.role}) | Complexity: ${decision.complexity}/10 | Model: ${tierConfig?.model}
+         Reasoning: ${decision.reasoning}`;
+};

package/dist/skills.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Skills/Presets System
+ * Based on OpenHands skills and Aider prompts
+ * Provides specialized behavior presets for different tasks
+ */
+export interface Skill {
+    name: string;
+    description: string;
+    systemPrompt: string;
+    tools?: string[];
+    modelPreference?: string;
+    autoActions?: string[];
+}
+export declare const builtinSkills: Record<string, Skill>;
+export declare function getActiveSkill(): Skill;
+export declare function setActiveSkill(name: string): Skill | undefined;
+export declare function listSkills(): Skill[];
+export declare function loadSkillFromFile(path: string): Promise<Skill | null>;
+export declare function saveSkillToFile(skill: Skill, path: string): Promise<void>;
+export declare function loadCustomSkills(dir: string): Promise<Record<string, Skill>>;
+export declare function buildSkillPrompt(skill: Skill, context?: {
+    files?: string[];
+    repoMap?: string;
+    history?: string;
+}): string;