@stan-chen/simple-cli 0.2.1

package/dist/ui/server.js

@@ -0,0 +1,74 @@
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { getContextManager } from '../context.js';
+import { createProvider } from '../providers/index.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export async function startServer(options) {
+    const { port, host } = options;
+    // Initialize Simple-CLI core
+    const ctx = getContextManager();
+    await ctx.initialize();
+    const provider = createProvider();
+    const server = http.createServer(async (req, res) => {
+        // Basic router
+        if (req.method === 'GET' && (req.url === '/' || req.url === '/index.html')) {
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end(fs.readFileSync(path.join(__dirname, 'index.html')));
+            return;
+        }
+        if (req.method === 'POST' && req.url === '/api/chat') {
+            let body = '';
+            req.on('data', chunk => { body += chunk; });
+            req.on('end', async () => {
+                try {
+                    const { message } = JSON.parse(body);
+                    if (!message) {
+                        res.writeHead(400);
+                        res.end(JSON.stringify({ error: 'Message required' }));
+                        return;
+                    }
+                    // Add message to context
+                    ctx.addMessage('user', message);
+                    // Get system prompt and history
+                    const systemPrompt = await ctx.buildSystemPrompt();
+                    const history = ctx.getHistory();
+                    // Generate response
+                    const response = await provider.generateResponse(systemPrompt, history.map(m => ({ role: m.role, content: m.content })));
+                    // Parse response (minimalist version of cli.ts logic)
+                    const thought = response.match(/<thought>([\s\S]*?)<\/thought>/)?.[1]?.trim();
+                    const jsonMatch = response.match(/\{[\s\S]*"tool"[\s\S]*\}/);
+                    let action = { tool: 'none', message: 'No action', args: {} };
+                    if (jsonMatch) {
+                        try {
+                            action = JSON.parse(jsonMatch[0]);
+                        }
+                        catch { /* ignore */ }
+                    }
+                    const messageText = action.message || response.replace(/<thought>[\s\S]*?<\/thought>/, '').replace(/\{[\s\S]*"tool"[\s\S]*\}/, '').trim();
+                    // Update context
+                    ctx.addMessage('assistant', response);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        message: messageText,
+                        thought,
+                        action
+                    }));
+                }
+                catch (error) {
+                    res.writeHead(500);
+                    res.end(JSON.stringify({ error: error.message }));
+                }
+            });
+            return;
+        }
+        // 404
+        res.writeHead(404);
+        res.end('Not Found');
+    });
+    server.listen(port, host, () => {
+        console.log(`\n🚀 Simple-CLI UI running at http://${host}:${port}`);
+        console.log(`   Press Ctrl+C to stop\n`);
+    });
+}

package/dist/watcher.d.ts

@@ -0,0 +1,35 @@
+/**
+ * File Watcher - Watch files for changes and AI comments
+ * Uses chokidar for robust cross-platform watching
+ */
+import { EventEmitter } from 'events';
+export interface WatcherOptions {
+    root: string;
+    ignorePatterns?: RegExp[];
+    onFileChange?: (filePath: string, type: 'add' | 'change' | 'unlink') => void;
+    onAIComment?: (filePath: string, comments: AIComment[]) => void;
+    verbose?: boolean;
+}
+export interface AIComment {
+    line: number;
+    text: string;
+    action: 'request' | 'question' | 'note';
+}
+export declare class FileWatcher extends EventEmitter {
+    private options;
+    private watcher;
+    private watchedFiles;
+    private ignorePatterns;
+    private verbose;
+    constructor(options: WatcherOptions);
+    start(): void;
+    stop(): void;
+    private shouldIgnore;
+    private handleChange;
+    private handleUnlink;
+    private extractAIComments;
+    hasActionableComments(): boolean;
+    getActionableCommentsPrompt(): string;
+    private log;
+}
+export declare function createFileWatcher(options: WatcherOptions): FileWatcher;

package/dist/watcher.js

@@ -0,0 +1,164 @@
+/**
+ * File Watcher - Watch files for changes and AI comments
+ * Uses chokidar for robust cross-platform watching
+ */
+import * as chokidar from 'chokidar';
+import { readFile } from 'fs/promises';
+import { relative } from 'path';
+import { EventEmitter } from 'events';
+// AI comment pattern (matches: # ai!, // ai?, -- ai, etc.)
+const AI_COMMENT_PATTERN = /(?:#|\/\/|--|;+)\s*(ai\b.*|ai\b.*|.*\bai[?!]?)\s*$/i;
+// Default ignore patterns
+const IGNORE_PATTERNS = [
+    /node_modules/,
+    /\.git/,
+    /dist\//,
+    /build\//,
+    /\.next/,
+    /\.nuxt/,
+    /__pycache__/,
+    /\.pytest_cache/,
+    /\.venv/,
+    /venv/,
+    /\.env$/,
+    /\.DS_Store/,
+    /\.swp$/,
+    /\.swo$/,
+    /\.bak$/,
+    /~$/,
+    /\.tmp$/,
+    /\.log$/,
+];
+const MAX_FILE_SIZE = 1024 * 1024; // 1MB
+export class FileWatcher extends EventEmitter {
+    options;
+    watcher = null;
+    watchedFiles = new Map();
+    ignorePatterns;
+    verbose;
+    constructor(options) {
+        super();
+        this.options = options;
+        this.ignorePatterns = [...IGNORE_PATTERNS, ...(options.ignorePatterns || [])];
+        this.verbose = options.verbose || false;
+        if (options.onFileChange)
+            this.on('file-change', options.onFileChange);
+        if (options.onAIComment)
+            this.on('ai-comment', options.onAIComment);
+    }
+    start() {
+        if (this.watcher)
+            return;
+        this.log(`Starting chokidar watcher on ${this.options.root}`);
+        this.watcher = chokidar.watch(this.options.root, {
+            ignored: (path) => this.shouldIgnore(path),
+            persistent: true,
+            ignoreInitial: false,
+            awaitWriteFinish: {
+                stabilityThreshold: 300,
+                pollInterval: 100
+            }
+        });
+        this.watcher
+            .on('add', (path) => this.handleChange(path, 'add'))
+            .on('change', (path) => this.handleChange(path, 'change'))
+            .on('unlink', (path) => this.handleUnlink(path));
+    }
+    stop() {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+            this.log('Watcher stopped');
+        }
+        this.watchedFiles.clear();
+    }
+    shouldIgnore(path) {
+        const relPath = relative(this.options.root, path);
+        // Always include root
+        if (path === this.options.root)
+            return false;
+        return this.ignorePatterns.some(pattern => pattern.test(relPath));
+    }
+    async handleChange(path, type) {
+        const relPath = relative(this.options.root, path);
+        // Skip large files (chokidar might have already stat-ed, but we want to be safe before reading)
+        // Note: chokidar doesn't expose stat size in event easily without another stat call or 'add' stats arg
+        // For simplicity, we just read.
+        try {
+            // ... Check size logic could go here if critical
+            const comments = await this.extractAIComments(path);
+            const existing = this.watchedFiles.get(path);
+            const hasNewComments = comments.length > 0 && (!existing || JSON.stringify(comments) !== JSON.stringify(existing.aiComments));
+            this.watchedFiles.set(path, { path, aiComments: comments });
+            this.emit('file-change', relPath, type);
+            if (hasNewComments) {
+                this.emit('ai-comment', relPath, comments);
+            }
+        }
+        catch (e) {
+            this.log(`Error processing ${relPath}: ${e}`);
+        }
+    }
+    handleUnlink(path) {
+        const relPath = relative(this.options.root, path);
+        this.watchedFiles.delete(path);
+        this.emit('file-change', relPath, 'unlink');
+    }
+    async extractAIComments(filePath) {
+        try {
+            const content = await readFile(filePath, 'utf-8');
+            if (content.length > MAX_FILE_SIZE)
+                return [];
+            const lines = content.split('\n');
+            const comments = [];
+            for (let i = 0; i < lines.length; i++) {
+                const match = AI_COMMENT_PATTERN.exec(lines[i]);
+                if (match) {
+                    const text = match[1].trim();
+                    let action = 'note';
+                    const lower = text.toLowerCase();
+                    if (lower.endsWith('!') || lower.startsWith('ai!'))
+                        action = 'request';
+                    else if (lower.endsWith('?') || lower.startsWith('ai?'))
+                        action = 'question';
+                    comments.push({ line: i + 1, text, action });
+                }
+            }
+            return comments;
+        }
+        catch {
+            return [];
+        }
+    }
+    hasActionableComments() {
+        for (const [_, file] of this.watchedFiles) {
+            if (file.aiComments.some(c => c.action === 'request' || c.action === 'question')) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getActionableCommentsPrompt() {
+        const parts = [];
+        for (const [path, file] of this.watchedFiles) {
+            const actionable = file.aiComments.filter(c => c.action === 'request' || c.action === 'question');
+            if (actionable.length > 0) {
+                const relPath = relative(this.options.root, path);
+                parts.push(`\n${relPath}:`);
+                for (const c of actionable) {
+                    parts.push(`  Line ${c.line} [${c.action === 'request' ? '!' : '?'}]: ${c.text}`);
+                }
+            }
+        }
+        return parts.length > 0 ? `The following AI comments were found in the codebase:${parts.join('\n')}` : '';
+    }
+    log(msg) {
+        if (this.verbose)
+            console.log(`[Watcher] ${msg}`);
+    }
+}
+export function createFileWatcher(options) {
+    const w = new FileWatcher(options);
+    w.start();
+    return w;
+}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@stan-chen/simple-cli",
+  "version": "0.2.1",
+  "description": "A lean, lightweight coding agent. Packs a punch with token efficiency.",
+  "type": "module",
+  "main": "dist/cli.js",
+  "bin": {
+    "simple": "dist/cli.js"
+  },
+  "scripts": {
+    "start": "node --loader ts-node/esm src/cli.ts",
+    "dev": "node --loader ts-node/esm --watch src/index.ts",
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint src/ tests/",
+    "format": "prettier --write src/ tests/"
+  },
+  "keywords": [
+    "cli",
+    "agent",
+    "coding-assistant",
+    "llm",
+    "mcp",
+    "ai",
+    "openai",
+    "anthropic",
+    "gemini",
+    "litellm",
+    "aider"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.7.0",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@oclif/core": "^4.0.0",
+    "chalk": "^5.3.0",
+    "chokidar": "^5.0.0",
+    "diff": "^5.2.0",
+    "dotenv": "^16.4.7",
+    "fast-glob": "^3.3.2",
+    "fast-levenshtein": "^3.0.0",
+    "glob": "^13.0.0",
+    "gpt-tokenizer": "^2.5.0",
+    "jsonrepair": "^3.13.2",
+    "openai": "^6.16.0",
+    "ora": "^8.0.0",
+    "picocolors": "^1.0.0",
+    "simple-git": "^3.22.0",
+    "ts-morph": "^22.0.0",
+    "turndown": "^7.2.0",
+    "yaml": "^2.8.2",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@oclif/test": "^4.0.0",
+    "@types/chokidar": "^1.7.5",
+    "@types/diff": "^5.2.3",
+    "@types/fast-levenshtein": "^0.0.4",
+    "@types/node": "^22.19.7",
+    "@types/turndown": "^5.0.5",
+    "oclif": "^4.0.0",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "docs/assets/logo.jpeg"
+  ]
+}