@stan-chen/simple-cli 0.2.2 → 0.2.4

package/dist/context.js

@@ -1,327 +0,0 @@
-/**
- * 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

@@ -1,6 +0,0 @@
-#!/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

@@ -1,109 +0,0 @@
-#!/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

@@ -1,98 +0,0 @@
-/**
- * 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[]>;