@stan-chen/simple-cli 0.2.3 → 0.2.5

package/dist/tools/memory.js

@@ -1,215 +0,0 @@
-/**
- * Memory Tool - Persistent context and memory management
- * Based on GeminiCLI's memoryTool.ts
- */
-import { z } from 'zod';
-import { readFile, writeFile, mkdir } from 'fs/promises';
-import { existsSync } from 'fs';
-import { join, dirname } from 'path';
-// Input schema
-export const inputSchema = z.object({
-    operation: z.enum(['get', 'set', 'delete', 'list', 'search', 'clear']).describe('Memory operation'),
-    key: z.string().optional().describe('Memory key'),
-    value: z.string().optional().describe('Value to store'),
-    query: z.string().optional().describe('Search query'),
-    namespace: z.string().optional().default('default').describe('Memory namespace'),
-});
-// Get memory file path
-function getMemoryPath() {
-    const baseDir = process.env.SIMPLE_CLI_DATA_DIR ||
-        join(process.env.HOME || '', '.config', 'simplecli');
-    return join(baseDir, 'memory.json');
-}
-// Load memory store
-async function loadMemory() {
-    const path = getMemoryPath();
-    if (!existsSync(path)) {
-        return { version: 1, entries: {} };
-    }
-    try {
-        const content = await readFile(path, 'utf-8');
-        return JSON.parse(content);
-    }
-    catch {
-        return { version: 1, entries: {} };
-    }
-}
-// Save memory store
-async function saveMemory(store) {
-    const path = getMemoryPath();
-    // Ensure directory exists
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, JSON.stringify(store, null, 2));
-}
-// Generate unique key
-function generateKey(namespace, key) {
-    return `${namespace}:${key}`;
-}
-// Execute memory operation
-export async function execute(input) {
-    const { operation, key, value, query, namespace } = inputSchema.parse(input);
-    const store = await loadMemory();
-    try {
-        switch (operation) {
-            case 'get': {
-                if (!key) {
-                    return {
-                        operation,
-                        success: false,
-                        error: 'Key required for get operation',
-                    };
-                }
-                const fullKey = generateKey(namespace, key);
-                const entry = store.entries[fullKey];
-                if (!entry) {
-                    return {
-                        operation,
-                        success: true,
-                        data: null,
-                    };
-                }
-                return {
-                    operation,
-                    success: true,
-                    data: {
-                        key: entry.key,
-                        value: entry.value,
-                        timestamp: entry.timestamp,
-                    },
-                };
-            }
-            case 'set': {
-                if (!key || value === undefined) {
-                    return {
-                        operation,
-                        success: false,
-                        error: 'Key and value required for set operation',
-                    };
-                }
-                const fullKey = generateKey(namespace, key);
-                store.entries[fullKey] = {
-                    key,
-                    value,
-                    timestamp: Date.now(),
-                    namespace,
-                };
-                await saveMemory(store);
-                return {
-                    operation,
-                    success: true,
-                    data: { key, stored: true },
-                };
-            }
-            case 'delete': {
-                if (!key) {
-                    return {
-                        operation,
-                        success: false,
-                        error: 'Key required for delete operation',
-                    };
-                }
-                const fullKey = generateKey(namespace, key);
-                const existed = fullKey in store.entries;
-                delete store.entries[fullKey];
-                await saveMemory(store);
-                return {
-                    operation,
-                    success: true,
-                    data: { key, deleted: existed },
-                };
-            }
-            case 'list': {
-                const entries = Object.values(store.entries)
-                    .filter(e => e.namespace === namespace)
-                    .map(e => ({
-                    key: e.key,
-                    timestamp: e.timestamp,
-                    preview: e.value.slice(0, 100) + (e.value.length > 100 ? '...' : ''),
-                }))
-                    .sort((a, b) => b.timestamp - a.timestamp);
-                return {
-                    operation,
-                    success: true,
-                    data: {
-                        namespace,
-                        count: entries.length,
-                        entries,
-                    },
-                };
-            }
-            case 'search': {
-                if (!query) {
-                    return {
-                        operation,
-                        success: false,
-                        error: 'Query required for search operation',
-                    };
-                }
-                const queryLower = query.toLowerCase();
-                const matches = Object.values(store.entries)
-                    .filter(e => e.key.toLowerCase().includes(queryLower) ||
-                    e.value.toLowerCase().includes(queryLower))
-                    .map(e => ({
-                    key: e.key,
-                    namespace: e.namespace,
-                    timestamp: e.timestamp,
-                    preview: e.value.slice(0, 100) + (e.value.length > 100 ? '...' : ''),
-                }))
-                    .slice(0, 20);
-                return {
-                    operation,
-                    success: true,
-                    data: {
-                        query,
-                        count: matches.length,
-                        matches,
-                    },
-                };
-            }
-            case 'clear': {
-                const beforeCount = Object.keys(store.entries).length;
-                if (namespace === 'all') {
-                    store.entries = {};
-                }
-                else {
-                    for (const [k, entry] of Object.entries(store.entries)) {
-                        if (entry.namespace === namespace) {
-                            delete store.entries[k];
-                        }
-                    }
-                }
-                await saveMemory(store);
-                const afterCount = Object.keys(store.entries).length;
-                return {
-                    operation,
-                    success: true,
-                    data: {
-                        namespace,
-                        cleared: beforeCount - afterCount,
-                    },
-                };
-            }
-            default:
-                return {
-                    operation,
-                    success: false,
-                    error: `Unknown operation: ${operation}`,
-                };
-        }
-    }
-    catch (error) {
-        return {
-            operation,
-            success: false,
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-// Tool definition
-export const tool = {
-    name: 'memory',
-    description: 'Store and retrieve persistent memory/context. Operations: get, set, delete, list, search, clear',
-    inputSchema,
-    permission: 'write',
-    execute: async (args) => execute(args),
-};

package/dist/tools/organizer.d.ts

@@ -1 +0,0 @@
-export declare function runDeterministicOrganizer(targetDir: string): void;

package/dist/tools/organizer.js

@@ -1,65 +0,0 @@
-import fs from 'fs';
-import pc from 'picocolors';
-import { join } from 'path';
-export function runDeterministicOrganizer(targetDir) {
-    try {
-        console.log(pc.yellow('⚙ Running deterministic organizer fallback...'));
-        const photosDir = join(targetDir, 'Photos');
-        const docsDir = join(targetDir, 'Documents');
-        const trashDir = join(targetDir, 'Trash');
-        const expensesPath = join(targetDir, 'Expenses.csv');
-        if (!fs.existsSync(photosDir))
-            fs.mkdirSync(photosDir, { recursive: true });
-        if (!fs.existsSync(docsDir))
-            fs.mkdirSync(docsDir, { recursive: true });
-        if (!fs.existsSync(trashDir))
-            fs.mkdirSync(trashDir, { recursive: true });
-        const entries = fs.readdirSync(targetDir);
-        for (const f of entries) {
-            const src = join(targetDir, f);
-            try {
-                const stat = fs.statSync(src);
-                if (!stat.isFile())
-                    continue;
-            }
-            catch {
-                continue;
-            }
-            const lower = f.toLowerCase();
-            try {
-                if (lower.endsWith('.jpg') || lower.endsWith('.png')) {
-                    console.log(pc.dim(`  -> Moving ${f} to Photos`));
-                    fs.renameSync(src, join(photosDir, f));
-                }
-                else if (lower.endsWith('.pdf') || lower.endsWith('.docx')) {
-                    console.log(pc.dim(`  -> Moving ${f} to Documents`));
-                    fs.renameSync(src, join(docsDir, f));
-                }
-                else if (lower.endsWith('.exe') || lower.endsWith('.msi')) {
-                    console.log(pc.dim(`  -> Moving ${f} to Trash`));
-                    fs.renameSync(src, join(trashDir, f));
-                }
-                else if ((lower.includes('receipt') || lower.startsWith('receipt')) && lower.endsWith('.txt')) {
-                    const content = fs.readFileSync(src, 'utf-8');
-                    const m = content.match(/Total:\s*\$?([0-9]+(?:\.[0-9]{1,2})?)/i);
-                    if (m) {
-                        const line = `${new Date().toISOString().split('T')[0]},${m[1]},${f}\n`;
-                        if (!fs.existsSync(expensesPath))
-                            fs.appendFileSync(expensesPath, 'Date,Amount,Description\n');
-                        fs.appendFileSync(expensesPath, line);
-                        console.log(pc.dim(`  -> Logged receipt: ${f}`));
-                    }
-                    console.log(pc.dim(`  -> Moving ${f} to Documents`));
-                    fs.renameSync(src, join(docsDir, f));
-                }
-            }
-            catch (err) {
-                console.error(pc.red(`  ! Failed to process ${f}:`), err instanceof Error ? err.message : err);
-            }
-        }
-        console.log(pc.green('✔ Deterministic organizer finished'));
-    }
-    catch (err) {
-        console.error('Fallback organizer failed:', err);
-    }
-}

package/dist/tools/readFiles.d.ts

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

@@ -1,31 +0,0 @@
-/**
- * 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/read_files.d.ts

@@ -1,25 +0,0 @@
-/**
- * Tool: readFiles
- * Read contents of one or more files
- */
-import { z } from 'zod';
-export declare const name = "read_files";
-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/read_files.js

@@ -1,31 +0,0 @@
-/**
- * Tool: readFiles
- * Read contents of one or more files
- */
-import { readFile } from 'fs/promises';
-import { z } from 'zod';
-export const name = 'read_files';
-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

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

@@ -1,22 +0,0 @@
-/**
- * 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/reload_tools.d.ts

@@ -1,11 +0,0 @@
-/**
- * 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 = "reload_tools";
-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/reload_tools.js

@@ -1,22 +0,0 @@
-/**
- * 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 = 'reload_tools';
-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

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

@@ -1,79 +0,0 @@
-/**
- * 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/run_command.d.ts

@@ -1,32 +0,0 @@
-/**
- * Tool: runCommand
- * Execute shell commands in a sandboxed environment
- */
-import { z } from 'zod';
-export declare const name = "run_command";
-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 {};