@stan-chen/simple-cli 0.2.1

package/dist/tools/readFiles.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Tool: readFiles
+ * Read contents of one or more files
+ */
+import { z } from 'zod';
+export declare const name = "readFiles";
+export declare const description = "Read the contents of one or more files from the filesystem";
+export declare const permission: "read";
+export declare const schema: z.ZodObject<{
+    paths: z.ZodArray<z.ZodString, "many">;
+    encoding: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    paths: string[];
+    encoding?: string | undefined;
+}, {
+    paths: string[];
+    encoding?: string | undefined;
+}>;
+interface FileResult {
+    path: string;
+    content?: string;
+    error?: string;
+}
+export declare const execute: (args: Record<string, unknown>) => Promise<FileResult[]>;
+export {};

package/dist/tools/readFiles.js

@@ -0,0 +1,31 @@
+/**
+ * Tool: readFiles
+ * Read contents of one or more files
+ */
+import { readFile } from 'fs/promises';
+import { z } from 'zod';
+export const name = 'readFiles';
+export const description = 'Read the contents of one or more files from the filesystem';
+export const permission = 'read';
+export const schema = z.object({
+    paths: z.array(z.string()).describe('Array of file paths to read'),
+    encoding: z.string().optional().describe('File encoding (default: utf-8)')
+});
+export const execute = async (args) => {
+    const parsed = schema.parse(args);
+    const encoding = (parsed.encoding || 'utf-8');
+    const results = [];
+    for (const path of parsed.paths) {
+        try {
+            const content = await readFile(path, encoding);
+            results.push({ path, content });
+        }
+        catch (error) {
+            results.push({
+                path,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    }
+    return results;
+};

package/dist/tools/reloadTools.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Tool: reloadTools
+ * Reloads all tools, including built-in, MCP, and project-specific skills.
+ * Use this after creating a new skill file in the 'skills/' directory.
+ */
+import { z } from 'zod';
+export declare const name = "reloadTools";
+export declare const description = "Reload all tools to pick up new skills or changes to existing tools";
+export declare const permission: "read";
+export declare const schema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const execute: (_args: Record<string, unknown>) => Promise<string>;

package/dist/tools/reloadTools.js

@@ -0,0 +1,22 @@
+/**
+ * Tool: reloadTools
+ * Reloads all tools, including built-in, MCP, and project-specific skills.
+ * Use this after creating a new skill file in the 'skills/' directory.
+ */
+import { z } from 'zod';
+import { getContextManager } from '../context.js';
+export const name = 'reloadTools';
+export const description = 'Reload all tools to pick up new skills or changes to existing tools';
+export const permission = 'read';
+export const schema = z.object({});
+export const execute = async (_args) => {
+    const ctx = getContextManager();
+    await ctx.initialize();
+    const tools = ctx.getTools();
+    const summary = Array.from(tools.values()).reduce((acc, tool) => {
+        const source = tool.source || 'unknown';
+        acc[source] = (acc[source] || 0) + 1;
+        return acc;
+    }, {});
+    return `All tools reloaded successfully.\n\nSummary:\n- Built-in: ${summary.builtin || 0}\n- Project Skills: ${summary.project || 0}\n- MCP Tools: ${summary.mcp || 0}\n\nNewly discovered/updated tools are now ready for use.`;
+};

package/dist/tools/runCommand.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Tool: runCommand
+ * Execute shell commands in a sandboxed environment
+ */
+import { z } from 'zod';
+export declare const name = "runCommand";
+export declare const description = "Execute a shell command with timeout and environment restrictions";
+export declare const permission: "execute";
+export declare const schema: z.ZodObject<{
+    command: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    command: string;
+    env?: Record<string, string> | undefined;
+    timeout?: number | undefined;
+    cwd?: string | undefined;
+}, {
+    command: string;
+    env?: Record<string, string> | undefined;
+    timeout?: number | undefined;
+    cwd?: string | undefined;
+}>;
+interface CommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+}
+export declare const execute: (args: Record<string, unknown>) => Promise<CommandResult>;
+export {};

package/dist/tools/runCommand.js

@@ -0,0 +1,79 @@
+/**
+ * Tool: runCommand
+ * Execute shell commands in a sandboxed environment
+ */
+import { spawn } from 'child_process';
+import { z } from 'zod';
+export const name = 'runCommand';
+export const description = 'Execute a shell command with timeout and environment restrictions';
+export const permission = 'execute';
+export const schema = z.object({
+    command: z.string().describe('The shell command to execute'),
+    cwd: z.string().optional().describe('Working directory for the command'),
+    timeout: z.number().optional().describe('Timeout in milliseconds (default: 30000)'),
+    env: z.record(z.string()).optional().describe('Additional environment variables')
+});
+// Restricted environment - remove sensitive variables
+const createSafeEnv = (additionalEnv) => {
+    // Inherit the full host environment to ensure tools like 'gh', 'git', etc.
+    // can access their configuration and credentials.
+    const env = { ...process.env };
+    // Add any additional env vars
+    if (additionalEnv) {
+        Object.assign(env, additionalEnv);
+    }
+    return env;
+};
+export const execute = async (args) => {
+    const parsed = schema.parse(args);
+    const timeout = parsed.timeout || 30000;
+    const env = createSafeEnv(parsed.env);
+    return new Promise((resolve) => {
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        const child = spawn(parsed.command, {
+            shell: true,
+            cwd: parsed.cwd || process.cwd(),
+            env,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGTERM');
+            setTimeout(() => child.kill('SIGKILL'), 1000);
+        }, timeout);
+        child.stdout?.on('data', (data) => {
+            stdout += data.toString();
+            // Limit output size
+            if (stdout.length > 100000) {
+                stdout = stdout.slice(0, 100000) + '\n... (output truncated)';
+                child.kill('SIGTERM');
+            }
+        });
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+            if (stderr.length > 50000) {
+                stderr = stderr.slice(0, 50000) + '\n... (output truncated)';
+            }
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            resolve({
+                exitCode: code ?? 1,
+                stdout: stdout.trim(),
+                stderr: stderr.trim(),
+                timedOut
+            });
+        });
+        child.on('error', (error) => {
+            clearTimeout(timer);
+            resolve({
+                exitCode: 1,
+                stdout: '',
+                stderr: error.message,
+                timedOut: false
+            });
+        });
+    });
+};

package/dist/tools/scraper.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Web Scraper Tool - Fetches and converts web content to markdown
+ * Uses turndown for robust HTML to Markdown conversion (with regex fallback)
+ */
+import { z } from 'zod';
+import type { Tool } from '../registry.js';
+export declare const inputSchema: z.ZodObject<{
+    url: z.ZodString;
+    convertToMarkdown: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    verifySSL: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    timeout: number;
+    convertToMarkdown: boolean;
+    verifySSL: boolean;
+}, {
+    url: string;
+    timeout?: number | undefined;
+    convertToMarkdown?: boolean | undefined;
+    verifySSL?: boolean | undefined;
+}>;
+type ScraperInput = z.infer<typeof inputSchema>;
+export declare function execute(input: ScraperInput): Promise<{
+    url: string;
+    content: string;
+    contentType: string;
+    error?: string;
+}>;
+export declare const tool: Tool;
+export {};

package/dist/tools/scraper.js

@@ -0,0 +1,211 @@
+/**
+ * Web Scraper Tool - Fetches and converts web content to markdown
+ * Uses turndown for robust HTML to Markdown conversion (with regex fallback)
+ */
+import { z } from 'zod';
+// Input schema
+export const inputSchema = z.object({
+    url: z.string().url().describe('URL to scrape'),
+    convertToMarkdown: z.boolean().optional().default(true).describe('Convert HTML to Markdown'),
+    verifySSL: z.boolean().optional().default(true).describe('Verify SSL certificates'),
+    timeout: z.number().optional().default(30000).describe('Timeout in milliseconds'),
+});
+// Cached turndown instance
+let turndownInstance = null;
+let turndownLoaded = false;
+// Get or create turndown instance (lazy load)
+async function getTurndown() {
+    if (!turndownLoaded) {
+        turndownLoaded = true;
+        try {
+            const mod = await import('turndown');
+            const TurndownService = mod.default;
+            turndownInstance = new TurndownService({
+                headingStyle: 'atx',
+                hr: '---',
+                bulletListMarker: '-',
+                codeBlockStyle: 'fenced',
+                emDelimiter: '*',
+                strongDelimiter: '**',
+                linkStyle: 'inlined',
+            });
+            // Remove script and style elements
+            turndownInstance.remove(['script', 'style', 'noscript', 'iframe', 'svg']);
+            // Custom rule for code blocks with language hints
+            turndownInstance.addRule('codeBlock', {
+                filter: (node) => {
+                    return (node.nodeName === 'PRE' &&
+                        node.firstChild !== null &&
+                        node.firstChild.nodeName === 'CODE');
+                },
+                replacement: (_content, node) => {
+                    const codeNode = node.firstChild;
+                    const className = codeNode.getAttribute?.('class') || '';
+                    const langMatch = className.match(/language-(\w+)/);
+                    const lang = langMatch ? langMatch[1] : '';
+                    const code = codeNode.textContent || '';
+                    return `\n\n\`\`\`${lang}\n${code.trim()}\n\`\`\`\n\n`;
+                },
+            });
+        }
+        catch {
+            // turndown not installed, will use fallback
+        }
+    }
+    return turndownInstance;
+}
+// Fallback regex-based HTML to Markdown conversion
+function htmlToMarkdownFallback(html) {
+    let md = html;
+    // Remove script and style tags
+    md = md.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '');
+    md = md.replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, '');
+    // Convert headings
+    md = md.replace(/<h1[^>]*>(.*?)<\/h1>/gi, '\n# $1\n');
+    md = md.replace(/<h2[^>]*>(.*?)<\/h2>/gi, '\n## $1\n');
+    md = md.replace(/<h3[^>]*>(.*?)<\/h3>/gi, '\n### $1\n');
+    md = md.replace(/<h4[^>]*>(.*?)<\/h4>/gi, '\n#### $1\n');
+    md = md.replace(/<h5[^>]*>(.*?)<\/h5>/gi, '\n##### $1\n');
+    md = md.replace(/<h6[^>]*>(.*?)<\/h6>/gi, '\n###### $1\n');
+    // Convert paragraphs
+    md = md.replace(/<p[^>]*>(.*?)<\/p>/gis, '\n$1\n');
+    // Convert links
+    md = md.replace(/<a[^>]*href="([^"]*)"[^>]*>(.*?)<\/a>/gi, '[$2]($1)');
+    // Convert images
+    md = md.replace(/<img[^>]*src="([^"]*)"[^>]*alt="([^"]*)"[^>]*\/?>/gi, '![$2]($1)');
+    md = md.replace(/<img[^>]*src="([^"]*)"[^>]*\/?>/gi, '![]($1)');
+    // Convert bold
+    md = md.replace(/<strong[^>]*>(.*?)<\/strong>/gi, '**$1**');
+    md = md.replace(/<b[^>]*>(.*?)<\/b>/gi, '**$1**');
+    // Convert italic
+    md = md.replace(/<em[^>]*>(.*?)<\/em>/gi, '*$1*');
+    md = md.replace(/<i[^>]*>(.*?)<\/i>/gi, '*$1*');
+    // Convert inline code
+    md = md.replace(/<code[^>]*>(.*?)<\/code>/gi, '`$1`');
+    // Convert code blocks
+    md = md.replace(/<pre[^>]*><code[^>]*>(.*?)<\/code><\/pre>/gis, '\n```\n$1\n```\n');
+    md = md.replace(/<pre[^>]*>(.*?)<\/pre>/gis, '\n```\n$1\n```\n');
+    // Convert lists
+    md = md.replace(/<ul[^>]*>(.*?)<\/ul>/gis, (_, content) => {
+        return content.replace(/<li[^>]*>(.*?)<\/li>/gi, '- $1\n');
+    });
+    md = md.replace(/<ol[^>]*>(.*?)<\/ol>/gis, (_, content) => {
+        let i = 1;
+        return content.replace(/<li[^>]*>(.*?)<\/li>/gi, () => `${i++}. $1\n`);
+    });
+    // Convert blockquotes
+    md = md.replace(/<blockquote[^>]*>(.*?)<\/blockquote>/gis, (_, content) => {
+        return content.split('\n').map((line) => `> ${line}`).join('\n');
+    });
+    // Convert line breaks
+    md = md.replace(/<br\s*\/?>/gi, '\n');
+    // Convert horizontal rules
+    md = md.replace(/<hr\s*\/?>/gi, '\n---\n');
+    // Remove remaining HTML tags
+    md = md.replace(/<[^>]+>/g, '');
+    // Decode HTML entities
+    md = md.replace(/&nbsp;/g, ' ');
+    md = md.replace(/&amp;/g, '&');
+    md = md.replace(/&lt;/g, '<');
+    md = md.replace(/&gt;/g, '>');
+    md = md.replace(/&quot;/g, '"');
+    md = md.replace(/&#39;/g, "'");
+    // Clean up whitespace
+    md = md.replace(/\n{3,}/g, '\n\n');
+    md = md.trim();
+    return md;
+}
+// Slim down HTML by removing unnecessary elements before conversion
+function slimDownHtml(html) {
+    let slim = html;
+    // Remove SVG elements
+    slim = slim.replace(/<svg\b[^<]*(?:(?!<\/svg>)<[^<]*)*<\/svg>/gi, '');
+    // Remove data: URLs (large embedded content)
+    slim = slim.replace(/\s*(?:href|src)=["']data:[^"']*["']/gi, '');
+    // Remove inline styles
+    slim = slim.replace(/\s*style=["'][^"']*["']/gi, '');
+    // Remove tracking pixels and tiny images
+    slim = slim.replace(/<img[^>]*(?:width|height)=["']?[01](?:px)?["']?[^>]*>/gi, '');
+    return slim;
+}
+// Check if content looks like HTML
+function looksLikeHtml(content) {
+    const htmlPatterns = [
+        /<!DOCTYPE\s+html/i,
+        /<html/i,
+        /<head/i,
+        /<body/i,
+        /<div/i,
+        /<p>/i,
+        /<a\s+href=/i,
+    ];
+    return htmlPatterns.some(pattern => pattern.test(content));
+}
+// Convert HTML to Markdown using turndown or fallback
+async function htmlToMarkdown(html) {
+    const turndown = await getTurndown();
+    if (turndown) {
+        try {
+            return turndown.turndown(html);
+        }
+        catch {
+            // Fall through to regex fallback
+        }
+    }
+    return htmlToMarkdownFallback(html);
+}
+// Execute scraping
+export async function execute(input) {
+    const { url, convertToMarkdown, verifySSL, timeout } = inputSchema.parse(input);
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        const response = await fetch(url, {
+            signal: controller.signal,
+            headers: {
+                'User-Agent': 'simplecli/0.2.1 (+https://github.com/stancsz/simple-cli)',
+                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+            },
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            return {
+                url,
+                content: '',
+                contentType: '',
+                error: `HTTP ${response.status}: ${response.statusText}`,
+            };
+        }
+        const contentType = response.headers.get('content-type') || '';
+        let content = await response.text();
+        // Convert HTML to Markdown if requested
+        if (convertToMarkdown && (contentType.includes('text/html') || looksLikeHtml(content))) {
+            content = slimDownHtml(content);
+            content = await htmlToMarkdown(content);
+            // Clean up excessive whitespace
+            content = content.replace(/\n{3,}/g, '\n\n').trim();
+        }
+        return {
+            url,
+            content,
+            contentType,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            url,
+            content: '',
+            contentType: '',
+            error: errorMessage.includes('abort') ? 'Request timed out' : errorMessage,
+        };
+    }
+}
+// Tool definition
+export const tool = {
+    name: 'scrapeUrl',
+    description: 'Fetch a URL and convert its content to markdown. Useful for reading web pages, documentation, or API responses.',
+    inputSchema,
+    permission: 'read',
+    execute: async (args) => execute(args),
+};

package/dist/tools/writeFiles.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Tool: writeFiles
+ * Write or update files with search/replace support (Aider-style)
+ */
+import { z } from 'zod';
+export declare const name = "writeFiles";
+export declare const description = "Write or modify files. ALWAYS provide an array of objects in the \"files\" parameter, even for a single file. Each object must have \"path\" and either \"content\" (for full write) or \"searchReplace\" (for edits).";
+export declare const permission: "write";
+export declare const schema: z.ZodObject<{
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodOptional<z.ZodString>;
+        searchReplace: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            search: z.ZodString;
+            replace: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            replace: string;
+            search: string;
+        }, {
+            replace: string;
+            search: string;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        content?: string | undefined;
+        searchReplace?: {
+            replace: string;
+            search: string;
+        }[] | undefined;
+    }, {
+        path: string;
+        content?: string | undefined;
+        searchReplace?: {
+            replace: string;
+            search: string;
+        }[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    files: {
+        path: string;
+        content?: string | undefined;
+        searchReplace?: {
+            replace: string;
+            search: string;
+        }[] | undefined;
+    }[];
+}, {
+    files: {
+        path: string;
+        content?: string | undefined;
+        searchReplace?: {
+            replace: string;
+            search: string;
+        }[] | undefined;
+    }[];
+}>;
+interface WriteResult {
+    path: string;
+    success: boolean;
+    message: string;
+}
+export declare const execute: (args: Record<string, unknown>) => Promise<WriteResult[]>;
+export {};

package/dist/tools/writeFiles.js

@@ -0,0 +1,87 @@
+/**
+ * Tool: writeFiles
+ * Write or update files with search/replace support (Aider-style)
+ */
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { dirname, resolve } from 'path';
+import { z } from 'zod';
+export const name = 'writeFiles';
+export const description = 'Write or modify files. ALWAYS provide an array of objects in the "files" parameter, even for a single file. Each object must have "path" and either "content" (for full write) or "searchReplace" (for edits).';
+export const permission = 'write';
+const FileWriteSchema = z.object({
+    path: z.string().describe('File path to write'),
+    content: z.string().optional().describe('Full content to write (for new files or full rewrites)'),
+    searchReplace: z.array(z.object({
+        search: z.string().describe('Text to search for'),
+        replace: z.string().describe('Text to replace with')
+    })).optional().describe('Array of search/replace operations for targeted edits')
+});
+export const schema = z.object({
+    files: z.array(FileWriteSchema).describe('Array of files to write/modify')
+});
+export const execute = async (args) => {
+    const parsed = schema.parse(args);
+    const results = [];
+    for (const file of parsed.files) {
+        try {
+            // Ensure directory exists
+            await mkdir(dirname(file.path), { recursive: true });
+            if (file.content !== undefined) {
+                // Full file write
+                await writeFile(file.path, file.content, 'utf-8');
+                const absPath = resolve(file.path);
+                results.push({
+                    path: file.path,
+                    success: true,
+                    message: `File written successfully to ${absPath}`
+                });
+            }
+            else if (file.searchReplace && file.searchReplace.length > 0) {
+                // Search/replace operations
+                let content = await readFile(file.path, 'utf-8');
+                let changesApplied = 0;
+                const absPath = resolve(file.path);
+                for (const { search, replace } of file.searchReplace) {
+                    if (content.includes(search)) {
+                        // Apply replacement to all occurrences
+                        const newContent = content.replaceAll(search, replace);
+                        if (newContent !== content) {
+                            content = newContent;
+                            changesApplied++;
+                        }
+                    }
+                }
+                if (changesApplied > 0) {
+                    await writeFile(file.path, content, 'utf-8');
+                    results.push({
+                        path: file.path,
+                        success: true,
+                        message: `Applied ${changesApplied} search/replace operation(s) to ${absPath}`
+                    });
+                }
+                else {
+                    results.push({
+                        path: file.path,
+                        success: false,
+                        message: `No matching search patterns found in ${absPath}`
+                    });
+                }
+            }
+            else {
+                results.push({
+                    path: file.path,
+                    success: false,
+                    message: 'No content or searchReplace provided'
+                });
+            }
+        }
+        catch (error) {
+            results.push({
+                path: file.path,
+                success: false,
+                message: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    }
+    return results;
+};

package/dist/ui/server.d.ts

@@ -0,0 +1,5 @@
+export interface ServerOptions {
+    port: number;
+    host: string;
+}
+export declare function startServer(options: ServerOptions): Promise<void>;