@stan-chen/simple-cli 0.2.1

package/dist/context.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Context Manager - Manages conversation context and file state
+ * Based on Aider's coder.py and GeminiCLI's context management
+ * Uses gpt-tokenizer for accurate token counting (with fallback)
+ */
+import { type Skill } from './skills.js';
+import { type Tool } from './registry.js';
+export interface Message {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    timestamp?: number;
+}
+export interface ContextState {
+    cwd: string;
+    activeFiles: Set<string>;
+    readOnlyFiles: Set<string>;
+    history: Message[];
+    skill: Skill;
+    tokenEstimate: number;
+}
+/**
+ * Synchronous token count (uses cached encoder or estimation)
+ */
+declare function countTokens(text: string): number;
+/**
+ * ContextManager class
+ * Manages the conversation context, file state, and system prompts
+ */
+export declare class ContextManager {
+    private cwd;
+    private activeFiles;
+    private readOnlyFiles;
+    private history;
+    private skill;
+    private tools;
+    private repoMapCache;
+    private repoMapTimestamp;
+    constructor(cwd?: string);
+    /**
+     * Initialize the context manager
+     */
+    initialize(): Promise<void>;
+    /**
+     * Add a file to active context
+     */
+    addFile(path: string, readOnly?: boolean): boolean;
+    /**
+     * Remove a file from context
+     */
+    removeFile(path: string): boolean;
+    /**
+     * Add a message to history
+     */
+    addMessage(role: Message['role'], content: string): void;
+    /**
+     * Clear conversation history
+     */
+    clearHistory(): void;
+    /**
+     * Get all files in context
+     */
+    getFiles(): {
+        active: string[];
+        readOnly: string[];
+    };
+    /**
+     * Read all files in context
+     */
+    getFileContents(): Promise<Map<string, string>>;
+    /**
+     * Set the active skill
+     */
+    setSkill(skill: Skill): void;
+    /**
+     * Get the current skill
+     */
+    getSkill(): Skill;
+    /**
+     * Refresh the repository map
+     */
+    refreshRepoMap(): Promise<string>;
+    /**
+     * Build the system prompt
+     */
+    buildSystemPrompt(): Promise<string>;
+    /**
+     * Build messages for LLM
+     */
+    buildMessages(userMessage: string): Promise<Message[]>;
+    /**
+     * Estimate token count using accurate tokenizer
+     */
+    estimateTokenCount(): Promise<number>;
+    /**
+     * Get current state
+     */
+    getState(): ContextState;
+    /**
+     * Restore state
+     */
+    restoreState(state: Partial<ContextState>): void;
+    /**
+     * Get conversation history
+     */
+    getHistory(): Message[];
+    /**
+     * Get tools
+     */
+    getTools(): Map<string, Tool>;
+    /**
+     * Get working directory
+     */
+    getCwd(): string;
+}
+export declare function getContextManager(cwd?: string): ContextManager;
+export { countTokens };

package/dist/context.js

@@ -0,0 +1,327 @@
+/**
+ * Context Manager - Manages conversation context and file state
+ * Based on Aider's coder.py and GeminiCLI's context management
+ * Uses gpt-tokenizer for accurate token counting (with fallback)
+ */
+import { readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { relative, resolve } from 'path';
+import { generateRepoMap } from './repoMap.js';
+import { getActiveSkill } from './skills.js';
+import { loadAllTools, getToolDefinitions } from './registry.js';
+import { getPromptProvider } from './prompts/provider.js';
+// Cached tokenizer (typed as any to handle missing module)
+let tokenEncoder = null;
+let tokenizerLoaded = false;
+/**
+ * Load tokenizer lazily (handles case where gpt-tokenizer not installed)
+ */
+async function loadTokenizer() {
+    if (tokenizerLoaded)
+        return;
+    tokenizerLoaded = true;
+    try {
+        const mod = await import('gpt-tokenizer');
+        tokenEncoder = mod.encode;
+    }
+    catch {
+        // gpt-tokenizer not installed, will use fallback
+    }
+}
+/**
+ * Count tokens using gpt-tokenizer (accurate for GPT models)
+ * Falls back to rough estimation if not available
+ */
+async function countTokensAsync(text) {
+    await loadTokenizer();
+    if (tokenEncoder) {
+        try {
+            return tokenEncoder(text).length;
+        }
+        catch {
+            // Fall through to estimation
+        }
+    }
+    // Fallback: ~4 chars per token (rough but reasonable)
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Synchronous token count (uses cached encoder or estimation)
+ */
+function countTokens(text) {
+    if (tokenEncoder) {
+        try {
+            return tokenEncoder(text).length;
+        }
+        catch {
+            // Fall through
+        }
+    }
+    return Math.ceil(text.length / 4);
+}
+/**
+ * ContextManager class
+ * Manages the conversation context, file state, and system prompts
+ */
+export class ContextManager {
+    cwd;
+    activeFiles = new Set();
+    readOnlyFiles = new Set();
+    history = [];
+    skill;
+    tools = new Map();
+    repoMapCache = '';
+    repoMapTimestamp = 0;
+    constructor(cwd) {
+        this.cwd = cwd || process.cwd();
+        this.skill = getActiveSkill();
+    }
+    /**
+     * Initialize the context manager
+     */
+    async initialize() {
+        // Load tools
+        this.tools = await loadAllTools();
+        // Generate initial repo map
+        await this.refreshRepoMap();
+    }
+    /**
+     * Add a file to active context
+     */
+    addFile(path, readOnly = false) {
+        const fullPath = resolve(this.cwd, path);
+        if (!existsSync(fullPath)) {
+            return false;
+        }
+        if (readOnly) {
+            this.readOnlyFiles.add(fullPath);
+            this.activeFiles.delete(fullPath);
+        }
+        else {
+            this.activeFiles.add(fullPath);
+            this.readOnlyFiles.delete(fullPath);
+        }
+        return true;
+    }
+    /**
+     * Remove a file from context
+     */
+    removeFile(path) {
+        const fullPath = resolve(this.cwd, path);
+        const wasActive = this.activeFiles.delete(fullPath);
+        const wasReadOnly = this.readOnlyFiles.delete(fullPath);
+        return wasActive || wasReadOnly;
+    }
+    /**
+     * Add a message to history
+     */
+    addMessage(role, content) {
+        this.history.push({
+            role,
+            content,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * Clear conversation history
+     */
+    clearHistory() {
+        this.history = [];
+    }
+    /**
+     * Get all files in context
+     */
+    getFiles() {
+        return {
+            active: Array.from(this.activeFiles).map(f => relative(this.cwd, f)),
+            readOnly: Array.from(this.readOnlyFiles).map(f => relative(this.cwd, f)),
+        };
+    }
+    /**
+     * Read all files in context
+     */
+    async getFileContents() {
+        const contents = new Map();
+        for (const file of [...this.activeFiles, ...this.readOnlyFiles]) {
+            try {
+                const content = await readFile(file, 'utf-8');
+                const relPath = relative(this.cwd, file);
+                contents.set(relPath, content);
+            }
+            catch {
+                // Skip files that can't be read
+            }
+        }
+        return contents;
+    }
+    /**
+     * Set the active skill
+     */
+    setSkill(skill) {
+        this.skill = skill;
+    }
+    /**
+     * Get the current skill
+     */
+    getSkill() {
+        return this.skill;
+    }
+    /**
+     * Refresh the repository map
+     */
+    async refreshRepoMap() {
+        const now = Date.now();
+        // Cache for 30 seconds
+        if (this.repoMapCache && now - this.repoMapTimestamp < 30000) {
+            return this.repoMapCache;
+        }
+        this.repoMapCache = await generateRepoMap(this.cwd);
+        this.repoMapTimestamp = now;
+        return this.repoMapCache;
+    }
+    /**
+     * Build the system prompt
+     */
+    async buildSystemPrompt() {
+        const provider = getPromptProvider();
+        const systemPrompt = await provider.getSystemPrompt({
+            cwd: this.cwd,
+            skillPrompt: this.skill.systemPrompt
+        });
+        const parts = [systemPrompt];
+        // Tool definitions
+        const toolDefs = getToolDefinitions(this.tools);
+        parts.push('\n## Available Tools\n' + toolDefs);
+        // Active files
+        const files = this.getFiles();
+        if (files.active.length > 0 || files.readOnly.length > 0) {
+            parts.push('\n## Context Files');
+            if (files.active.length > 0) {
+                parts.push('\nEditable files:');
+                parts.push(files.active.map(f => `- ${f}`).join('\n'));
+            }
+            if (files.readOnly.length > 0) {
+                parts.push('\nRead-only files:');
+                parts.push(files.readOnly.map(f => `- ${f}`).join('\n'));
+            }
+        }
+        // Repository map (condensed)
+        const repoMap = await this.refreshRepoMap();
+        if (repoMap) {
+            const condensed = repoMap.split('\n').slice(0, 50).join('\n');
+            parts.push('\n## Repository Structure\n' + condensed);
+            if (repoMap.split('\n').length > 50) {
+                parts.push('... (truncated)');
+            }
+        }
+        return parts.join('\n');
+    }
+    /**
+     * Build messages for LLM
+     */
+    async buildMessages(userMessage) {
+        const messages = [];
+        // System prompt
+        const systemPrompt = await this.buildSystemPrompt();
+        messages.push({ role: 'system', content: systemPrompt });
+        // File contents as context
+        const fileContents = await this.getFileContents();
+        if (fileContents.size > 0) {
+            let fileContext = '## File Contents\n\n';
+            for (const [path, content] of fileContents) {
+                const truncated = content.length > 10000
+                    ? content.slice(0, 10000) + '\n... (truncated)'
+                    : content;
+                fileContext += `### ${path}\n\`\`\`\n${truncated}\n\`\`\`\n\n`;
+            }
+            messages.push({ role: 'user', content: fileContext });
+            messages.push({ role: 'assistant', content: 'I have read the files. How can I help?' });
+        }
+        // Conversation history
+        for (const msg of this.history) {
+            messages.push({ role: msg.role, content: msg.content });
+        }
+        // Current message
+        messages.push({ role: 'user', content: userMessage });
+        return messages;
+    }
+    /**
+     * Estimate token count using accurate tokenizer
+     */
+    async estimateTokenCount() {
+        // Ensure tokenizer is loaded
+        await loadTokenizer();
+        let total = 0;
+        // System prompt
+        const systemPrompt = await this.buildSystemPrompt();
+        total += countTokens(systemPrompt);
+        // File contents
+        const fileContents = await this.getFileContents();
+        for (const content of fileContents.values()) {
+            total += countTokens(content);
+        }
+        // History
+        for (const msg of this.history) {
+            total += countTokens(msg.content);
+        }
+        // Add overhead for message formatting (~4 tokens per message)
+        total += (this.history.length + 2) * 4;
+        return total;
+    }
+    /**
+     * Get current state
+     */
+    getState() {
+        return {
+            cwd: this.cwd,
+            activeFiles: this.activeFiles,
+            readOnlyFiles: this.readOnlyFiles,
+            history: this.history,
+            skill: this.skill,
+            tokenEstimate: 0, // Calculated async
+        };
+    }
+    /**
+     * Restore state
+     */
+    restoreState(state) {
+        if (state.cwd)
+            this.cwd = state.cwd;
+        if (state.activeFiles)
+            this.activeFiles = state.activeFiles;
+        if (state.readOnlyFiles)
+            this.readOnlyFiles = state.readOnlyFiles;
+        if (state.history)
+            this.history = state.history;
+        if (state.skill)
+            this.skill = state.skill;
+    }
+    /**
+     * Get conversation history
+     */
+    getHistory() {
+        return [...this.history];
+    }
+    /**
+     * Get tools
+     */
+    getTools() {
+        return this.tools;
+    }
+    /**
+     * Get working directory
+     */
+    getCwd() {
+        return this.cwd;
+    }
+}
+// Create a global context manager instance
+let globalContext = null;
+export function getContextManager(cwd) {
+    if (!globalContext) {
+        globalContext = new ContextManager(cwd);
+    }
+    return globalContext;
+}
+// Export token counting utility for use elsewhere
+export { countTokens };

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * Simple-CLI Orchestrator - Core loop: Observe -> Plan -> Verify -> Act -> Reflect
+ * Must remain under 150 lines. Supports MoE routing with --moe flag.
+ */
+import 'dotenv/config';

package/dist/index.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+/**
+ * Simple-CLI Orchestrator - Core loop: Observe -> Plan -> Verify -> Act -> Reflect
+ * Must remain under 150 lines. Supports MoE routing with --moe flag.
+ */
+import 'dotenv/config';
+import * as readline from 'readline';
+import { generateRepoMap } from './repoMap.js';
+import { loadTools } from './registry.js';
+import { createProvider } from './providers/index.js';
+import { createMultiProvider } from './providers/multi.js';
+import { routeTask, loadTierConfig, formatRoutingDecision } from './router.js';
+import { getPromptProvider } from './prompts/provider.js';
+const YOLO_MODE = process.argv.includes('--yolo');
+const MOE_MODE = process.argv.includes('--moe');
+let tools;
+let history = [];
+const buildPrompt = async () => {
+    const repoMap = await generateRepoMap();
+    const toolDefs = Array.from(tools.values()).map(t => `- ${t.name}: ${t.description}`).join('\n');
+    const provider = getPromptProvider();
+    const systemPrompt = await provider.getSystemPrompt({ cwd: process.cwd() });
+    return `${systemPrompt}
+## Context\n${repoMap}
+## Tools\n${toolDefs}
+## Format: <thought>reasoning</thought> then {"tool": "name", "args": {}} or {"tool": "none", "message": "..."}`;
+};
+import { jsonrepair } from 'jsonrepair';
+const parseResponse = (r) => {
+    const thought = r.match(/<thought>([\s\S]*?)<\/thought>/)?.[1]?.trim() || '';
+    const jsonMatch = r.match(/\{[\s\S]*"tool"[\s\S]*\}/);
+    let action = { tool: 'none', message: 'No action', args: {} };
+    if (jsonMatch) {
+        try {
+            const repaired = jsonrepair(jsonMatch[0]);
+            action = JSON.parse(repaired);
+        }
+        catch { /* use default */ }
+    }
+    return { thought, action };
+};
+const confirm = async (tool, args) => {
+    if (YOLO_MODE)
+        return true;
+    const t = tools.get(tool);
+    if (!t || t.permission === 'read')
+        return !!t;
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(res => {
+        rl.question(`[CONFIRM] ${tool}(${JSON.stringify(args)})? (y/n) `, a => { rl.close(); res(a.toLowerCase() === 'y'); });
+    });
+};
+const execTool = async (name, args) => {
+    const t = tools.get(name);
+    if (!t)
+        return `Error: Tool "${name}" not found`;
+    try {
+        const r = await t.execute(args);
+        return typeof r === 'string' ? r : JSON.stringify(r, null, 2);
+    }
+    catch (e) {
+        return `Error: ${e instanceof Error ? e.message : e}`;
+    }
+};
+const main = async () => {
+    console.log(`Simple-CLI v0.1.0 ${MOE_MODE ? '[MoE]' : ''} ${YOLO_MODE ? '[YOLO]' : '[Safe]'}`);
+    tools = await loadTools();
+    const systemPrompt = await buildPrompt();
+    const tierConfigs = MOE_MODE ? loadTierConfig() : null;
+    const multiProvider = tierConfigs ? createMultiProvider(tierConfigs) : null;
+    const singleProvider = !MOE_MODE ? createProvider() : null;
+    const generate = async (input) => {
+        if (MOE_MODE && multiProvider && tierConfigs) {
+            const routing = await routeTask(input, (p) => multiProvider.generateWithTier(1, p, [{ role: 'user', content: input }]));
+            console.log(formatRoutingDecision(routing, tierConfigs));
+            return multiProvider.generateWithTier(routing.tier, systemPrompt, history);
+        }
+        return singleProvider.generateResponse(systemPrompt, history);
+    };
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const prompt = () => {
+        rl.question('\n> ', async (input) => {
+            if (input.toLowerCase() === 'exit') {
+                rl.close();
+                return;
+            }
+            history.push({ role: 'user', content: input });
+            const response = await generate(input);
+            const { thought, action } = parseResponse(response);
+            console.log(`\n[Thought] ${thought}`);
+            if (action.tool !== 'none') {
+                if (await confirm(action.tool, action.args || {})) {
+                    const result = await execTool(action.tool, action.args || {});
+                    console.log(`[Result] ${result}`);
+                    history.push({ role: 'assistant', content: response }, { role: 'user', content: `Tool result: ${result}` });
+                }
+                else
+                    console.log('[Skipped]');
+            }
+            else {
+                console.log(`[Response] ${action.message}`);
+                history.push({ role: 'assistant', content: response });
+            }
+            prompt();
+        });
+    };
+    prompt();
+};
+main().catch(console.error);

package/dist/lib/agent.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Agent Core - Main agent loop with reflection and retry
+ * Implements Aider-style reasoning and error recovery
+ */
+import { Message } from '../context.js';
+import { EditBlock, EditResult } from './editor.js';
+import { GitManager } from './git.js';
+export interface AgentConfig {
+    maxReflections: number;
+    autoLint: boolean;
+    autoTest: boolean;
+    autoCommit: boolean;
+    testCommand?: string;
+    lintCommand?: string;
+}
+export interface ToolCall {
+    tool: string;
+    args: Record<string, unknown>;
+}
+export interface AgentResponse {
+    thought?: string;
+    action: ToolCall | {
+        tool: 'none';
+        message: string;
+    };
+    editBlocks?: EditBlock[];
+}
+export interface ReflectionContext {
+    attempt: number;
+    previousError: string;
+    previousResponse: string;
+    failedEdits: EditResult[];
+}
+/**
+ * Parse LLM response into structured format
+ */
+export declare function parseResponse(response: string): AgentResponse;
+/**
+ * Build reflection prompt for retry
+ */
+export declare function buildReflectionPrompt(context: ReflectionContext): string;
+/**
+ * Build lint error prompt
+ */
+export declare function buildLintErrorPrompt(file: string, errors: string): string;
+/**
+ * Build test failure prompt
+ */
+export declare function buildTestFailurePrompt(output: string): string;
+/**
+ * Agent class - Main orchestration logic
+ */
+export declare class Agent {
+    private config;
+    private git;
+    private generateFn;
+    private executeTool;
+    private lintFn?;
+    private testFn?;
+    constructor(options: {
+        config: AgentConfig;
+        git: GitManager;
+        generateFn: (messages: Message[]) => Promise<string>;
+        executeTool: (name: string, args: Record<string, unknown>) => Promise<unknown>;
+        lintFn?: (file: string) => Promise<{
+            passed: boolean;
+            output: string;
+        }>;
+        testFn?: () => Promise<{
+            passed: boolean;
+            output: string;
+        }>;
+    });
+    /**
+     * Process a user message with reflection loop
+     */
+    process(userMessage: string, history: Message[], systemPrompt: string): Promise<{
+        response: AgentResponse;
+        editResults: EditResult[];
+        lintResults: Array<{
+            file: string;
+            passed: boolean;
+            output: string;
+        }>;
+        testResult?: {
+            passed: boolean;
+            output: string;
+        };
+        commitResult?: {
+            hash: string;
+            message: string;
+        };
+    }>;
+}
+/**
+ * Summarize conversation history to reduce tokens
+ */
+export declare function summarizeHistory(history: Message[], generateFn: (messages: Message[]) => Promise<string>, maxMessages?: number): Promise<Message[]>;