@stan-chen/simple-cli 0.2.1 → 0.2.3

package/dist/tools/clawBrain.js

@@ -0,0 +1,136 @@
+/**
+ * ClawBrain - Agentic Reasoning and Persistence for Autonomous Mode
+ */
+import { z } from 'zod';
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join } from 'path';
+export const inputSchema = z.object({
+    action: z.enum(['set_goal', 'update_status', 'log_reflection', 'get_summary', 'prune', 'link_files']),
+    content: z.string().optional().describe('Text content for the action'),
+    status: z.enum(['planning', 'executing', 'completed', 'failed']).optional().describe('Current mission status'),
+    links: z.array(z.string()).optional().describe('Paths or IDs to link in the graph'),
+});
+const MISSION_FILE = '.simple/workdir/mission.json';
+async function loadMission(cwd) {
+    const path = join(cwd, MISSION_FILE);
+    if (!existsSync(path)) {
+        return { goal: 'Unknown', status: 'planning', reflections: [], lastUpdated: Date.now() };
+    }
+    try {
+        return JSON.parse(await readFile(path, 'utf-8'));
+    }
+    catch {
+        return { goal: 'Unknown', status: 'planning', reflections: [], lastUpdated: Date.now() };
+    }
+}
+async function saveMission(cwd, mission) {
+    const path = join(cwd, MISSION_FILE);
+    await mkdir(join(cwd, '.simple/workdir'), { recursive: true });
+    mission.lastUpdated = Date.now();
+    await writeFile(path, JSON.stringify(mission, null, 2));
+}
+export const execute = async (args, cwd = process.cwd()) => {
+    const { action, content, status, links } = inputSchema.parse(args);
+    const mission = await loadMission(cwd);
+    switch (action) {
+        case 'set_goal':
+            mission.goal = content || mission.goal;
+            if (status)
+                mission.status = status;
+            await saveMission(cwd, mission);
+            return { success: true, message: `Goal set to: ${mission.goal}` };
+        case 'update_status':
+            if (status)
+                mission.status = status;
+            if (content)
+                mission.reflections.push(`[Status Update] ${content}`);
+            await saveMission(cwd, mission);
+            return { success: true, status: mission.status };
+        case 'log_reflection':
+            if (content) {
+                mission.reflections.push(content);
+                if (mission.reflections.length > 50)
+                    mission.reflections.shift();
+                await saveMission(cwd, mission);
+                // Write to reflections directory for JIT context
+                const reflectionsDir = join(cwd, '.simple/workdir/memory/reflections');
+                await mkdir(reflectionsDir, { recursive: true });
+                const fileName = `reflection-${Date.now()}.md`;
+                await writeFile(join(reflectionsDir, fileName), content);
+            }
+            return { success: true, added: !!content };
+        case 'link_files':
+            if (links && links.length > 0) {
+                const graphDir = join(cwd, '.simple/workdir/memory/graph');
+                await mkdir(graphDir, { recursive: true });
+                const graphFile = join(graphDir, 'links.jsonl');
+                const entry = JSON.stringify({ timestamp: Date.now(), links, goal: mission.goal }) + '\n';
+                await writeFile(graphFile, entry, { flag: 'a' });
+            }
+            return { success: true, linked: links?.length || 0 };
+        case 'get_summary':
+            return {
+                goal: mission.goal,
+                status: mission.status,
+                recent_reflections: mission.reflections.slice(-5),
+                last_updated: new Date(mission.lastUpdated).toISOString()
+            };
+        case 'prune': {
+            const memoryDir = join(cwd, '.simple/workdir/memory');
+            const notesDir = join(memoryDir, 'notes');
+            await mkdir(notesDir, { recursive: true });
+            if (mission.reflections.length === 0) {
+                return { success: true, message: 'Nothing to prune.' };
+            }
+            const archiveFile = join(notesDir, `archive-${Date.now()}.md`);
+            let consolidated;
+            try {
+                const { createProvider } = await import('../providers/index.js');
+                const provider = createProvider();
+                const prompt = `Consolidate and summarize the following mission reflections into a concise technical brief. 
+                Keep ONLY unique technical insights, discovered paths, and finalized facts. 
+                Original Goal: ${mission.goal}\n\nReflections:\n${mission.reflections.join('\n')}`;
+                console.log('🤖 Summarizing reflections for pruning...');
+                const summary = await provider.generateResponse('You are a technical documentarian.', [
+                    { role: 'user', content: prompt }
+                ]);
+                let summaryText = summary;
+                try {
+                    const parsed = JSON.parse(summary);
+                    summaryText = parsed.thought || parsed.message || summary;
+                }
+                catch { /* not JSON */ }
+                consolidated = [
+                    `# Mission Summary Archive: ${mission.goal}`,
+                    `Status: ${mission.status}`,
+                    `Date: ${new Date().toISOString()}`,
+                    '',
+                    '## Executive Summary',
+                    summaryText
+                ].join('\n');
+            }
+            catch (e) {
+                // Fallback to basic concatenation if LLM fails
+                consolidated = mission.reflections.map(r => `- ${r}`).join('\n');
+            }
+            await writeFile(archiveFile, consolidated);
+            mission.reflections = mission.reflections.slice(-3); // Keep only very recent context
+            await saveMission(cwd, mission);
+            return {
+                success: true,
+                message: 'Memory pruned and summarized with LLM.',
+                archivePath: archiveFile
+            };
+        }
+        default:
+            throw new Error(`Invalid action: ${action}`);
+    }
+};
+export const tool = {
+    name: 'clawBrain',
+    description: 'Manage autonomous mission state and technical reasoning. Use to set goals, log reflections, and track status.',
+    inputSchema,
+    permission: 'write',
+    execute: async (args) => execute(args),
+};

package/dist/tools/claw_brain.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ClawBrain - Agentic Reasoning and Persistence for Autonomous Mode
+ */
+import { z } from 'zod';
+import type { Tool } from '../registry.js';
+export declare const inputSchema: z.ZodObject<{
+    action: z.ZodEnum<["set_goal", "update_status", "log_reflection", "get_summary", "prune", "link_files"]>;
+    content: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<["planning", "executing", "completed", "failed"]>>;
+    links: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    action: "log_reflection" | "get_summary" | "prune" | "set_goal" | "update_status" | "link_files";
+    status?: "completed" | "failed" | "planning" | "executing" | undefined;
+    content?: string | undefined;
+    links?: string[] | undefined;
+}, {
+    action: "log_reflection" | "get_summary" | "prune" | "set_goal" | "update_status" | "link_files";
+    status?: "completed" | "failed" | "planning" | "executing" | undefined;
+    content?: string | undefined;
+    links?: string[] | undefined;
+}>;
+export declare const execute: (args: Record<string, unknown>, cwd?: string) => Promise<any>;
+export declare const tool: Tool;

package/dist/tools/claw_brain.js

@@ -0,0 +1,139 @@
+/**
+ * ClawBrain - Agentic Reasoning and Persistence for Autonomous Mode
+ */
+import { z } from 'zod';
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join } from 'path';
+export const inputSchema = z.object({
+    action: z.enum(['set_goal', 'update_status', 'log_reflection', 'get_summary', 'prune', 'link_files']),
+    content: z.string().optional().describe('Text content for the action'),
+    status: z.enum(['planning', 'executing', 'completed', 'failed']).optional().describe('Current mission status'),
+    links: z.array(z.string()).optional().describe('Paths or IDs to link in the graph'),
+});
+const MISSION_FILE = '.simple/workdir/mission.json';
+async function loadMission(cwd) {
+    const path = join(cwd, MISSION_FILE);
+    if (!existsSync(path)) {
+        return { goal: 'Unknown', status: 'planning', reflections: [], lastUpdated: Date.now() };
+    }
+    try {
+        return JSON.parse(await readFile(path, 'utf-8'));
+    }
+    catch {
+        return { goal: 'Unknown', status: 'planning', reflections: [], lastUpdated: Date.now() };
+    }
+}
+async function saveMission(cwd, mission) {
+    const path = join(cwd, MISSION_FILE);
+    await mkdir(join(cwd, '.simple/workdir'), { recursive: true });
+    mission.lastUpdated = Date.now();
+    await writeFile(path, JSON.stringify(mission, null, 2));
+}
+export const execute = async (args, cwd = process.cwd()) => {
+    const { action, content, status, links } = inputSchema.parse(args);
+    const mission = await loadMission(cwd);
+    switch (action) {
+        case 'set_goal':
+            mission.goal = content || mission.goal;
+            if (status)
+                mission.status = status;
+            await saveMission(cwd, mission);
+            return { success: true, message: `Goal set to: ${mission.goal}` };
+        case 'update_status':
+            if (status)
+                mission.status = status;
+            if (content)
+                mission.reflections.push(`[Status Update] ${content}`);
+            await saveMission(cwd, mission);
+            return { success: true, status: mission.status };
+        case 'log_reflection':
+            if (content) {
+                mission.reflections.push(content);
+                if (mission.reflections.length > 50)
+                    mission.reflections.shift();
+                await saveMission(cwd, mission);
+                // Write to reflections directory for JIT context
+                const reflectionsDir = join(cwd, '.simple/workdir/memory/reflections');
+                await mkdir(reflectionsDir, { recursive: true });
+                const fileName = `reflection-${Date.now()}.md`;
+                await writeFile(join(reflectionsDir, fileName), content);
+            }
+            return { success: true, added: !!content };
+        case 'link_files':
+            if (links && links.length > 0) {
+                const graphDir = join(cwd, '.simple/workdir/memory/graph');
+                await mkdir(graphDir, { recursive: true });
+                const graphFile = join(graphDir, 'links.jsonl');
+                const entry = JSON.stringify({ timestamp: Date.now(), links, goal: mission.goal }) + '\n';
+                await writeFile(graphFile, entry, { flag: 'a' });
+            }
+            return { success: true, linked: links?.length || 0 };
+        case 'get_summary':
+            return {
+                goal: mission.goal,
+                status: mission.status,
+                recent_reflections: mission.reflections.slice(-5),
+                last_updated: new Date(mission.lastUpdated).toISOString()
+            };
+        case 'prune': {
+            const memoryDir = join(cwd, '.simple/workdir/memory');
+            const notesDir = join(memoryDir, 'notes');
+            await mkdir(notesDir, { recursive: true });
+            if (mission.reflections.length === 0) {
+                return { success: true, message: 'Nothing to prune.' };
+            }
+            const archiveFile = join(notesDir, `archive-${Date.now()}.md`);
+            let consolidated;
+            try {
+                const { createProvider } = await import('../providers/index.js');
+                const provider = createProvider();
+                const prompt = `Consolidate and summarize the following mission reflections into a concise technical brief. 
+                Keep ONLY unique technical insights, discovered paths, and finalized facts. 
+                Original Goal: ${mission.goal}\n\nReflections:\n${mission.reflections.join('\n')}`;
+                console.log('🤖 Summarizing reflections for pruning...');
+                const summary = await provider.generateResponse('You are a technical documentarian.', [
+                    { role: 'user', content: prompt }
+                ]);
+                let summaryText = summary.message || summary.thought || summary.raw || '';
+                try {
+                    // Try parsing raw if it looks like JSON and primary fields are empty
+                    if (!summaryText && summary.raw && (summary.raw.startsWith('{') || summary.raw.startsWith('['))) {
+                        const parsed = JSON.parse(summary.raw);
+                        summaryText = parsed.thought || parsed.message || summary.raw;
+                    }
+                }
+                catch { /* not JSON */ }
+                consolidated = [
+                    `# Mission Summary Archive: ${mission.goal}`,
+                    `Status: ${mission.status}`,
+                    `Date: ${new Date().toISOString()}`,
+                    '',
+                    '## Executive Summary',
+                    summaryText
+                ].join('\n');
+            }
+            catch (e) {
+                // Fallback to basic concatenation if LLM fails
+                consolidated = mission.reflections.map(r => `- ${r}`).join('\n');
+            }
+            await writeFile(archiveFile, consolidated);
+            mission.reflections = mission.reflections.slice(-3); // Keep only very recent context
+            await saveMission(cwd, mission);
+            return {
+                success: true,
+                message: 'Memory pruned and summarized with LLM.',
+                archivePath: archiveFile
+            };
+        }
+        default:
+            throw new Error(`Invalid action: ${action}`);
+    }
+};
+export const tool = {
+    name: 'claw_brain',
+    description: 'Manage autonomous mission state and technical reasoning. Use to set goals, log reflections, and track status.',
+    inputSchema,
+    permission: 'write',
+    execute: async (args) => execute(args),
+};

package/dist/tools/deleteFile.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Tool: delete_file
+ * Safely delete files
+ */
+import { z } from 'zod';
+export declare const name = "delete_file";
+export declare const description = "Delete a file from the filesystem. Use with caution.";
+export declare const permission: "write";
+export declare const schema: z.ZodObject<{
+    path: z.ZodString;
+    confirm: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    confirm: boolean;
+}, {
+    path: string;
+    confirm?: boolean | undefined;
+}>;
+export declare const execute: (args: Record<string, unknown>) => Promise<string>;

package/dist/tools/deleteFile.js

@@ -0,0 +1,36 @@
+/**
+ * Tool: delete_file
+ * Safely delete files
+ */
+import { unlink, stat } from 'fs/promises';
+import { resolve } from 'path';
+import { z } from 'zod';
+import { existsSync } from 'fs';
+export const name = 'delete_file';
+export const description = 'Delete a file from the filesystem. Use with caution.';
+export const permission = 'write';
+export const schema = z.object({
+    path: z.string().describe('Path to the file to delete'),
+    confirm: z.boolean().optional().default(false).describe('Confirmation flag (must be true to execute)')
+});
+export const execute = async (args) => {
+    const { path, confirm } = schema.parse(args);
+    if (!confirm) {
+        throw new Error('Deletion requires explicit confirmation. Set confirm=true to proceed.');
+    }
+    const fullPath = resolve(path);
+    if (!existsSync(fullPath)) {
+        throw new Error(`File not found: ${fullPath}`);
+    }
+    try {
+        const stats = await stat(fullPath);
+        if (stats.isDirectory()) {
+            throw new Error(`Path is a directory, not a file: ${fullPath}. Use a different tool for directories.`);
+        }
+        await unlink(fullPath);
+        return `Successfully deleted ${path}`;
+    }
+    catch (error) {
+        throw new Error(`Failed to delete file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};

package/dist/tools/delete_file.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Tool: delete_file
+ * Safely delete files
+ */
+import { z } from 'zod';
+export declare const name = "delete_file";
+export declare const description = "Delete a file from the filesystem. Use with caution.";
+export declare const permission: "write";
+export declare const schema: z.ZodObject<{
+    path: z.ZodString;
+    confirm: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    confirm: boolean;
+}, {
+    path: string;
+    confirm?: boolean | undefined;
+}>;
+export declare const execute: (args: Record<string, unknown>) => Promise<string>;

package/dist/tools/delete_file.js

@@ -0,0 +1,36 @@
+/**
+ * Tool: delete_file
+ * Safely delete files
+ */
+import { unlink, stat } from 'fs/promises';
+import { resolve } from 'path';
+import { z } from 'zod';
+import { existsSync } from 'fs';
+export const name = 'delete_file';
+export const description = 'Delete a file from the filesystem. Use with caution.';
+export const permission = 'write';
+export const schema = z.object({
+    path: z.string().describe('Path to the file to delete'),
+    confirm: z.boolean().optional().default(false).describe('Confirmation flag (must be true to execute)')
+});
+export const execute = async (args) => {
+    const { path, confirm } = schema.parse(args);
+    if (!confirm) {
+        throw new Error('Deletion requires explicit confirmation. Set confirm=true to proceed.');
+    }
+    const fullPath = resolve(path);
+    if (!existsSync(fullPath)) {
+        throw new Error(`File not found: ${fullPath}`);
+    }
+    try {
+        const stats = await stat(fullPath);
+        if (stats.isDirectory()) {
+            throw new Error(`Path is a directory, not a file: ${fullPath}. Use a different tool for directories.`);
+        }
+        await unlink(fullPath);
+        return `Successfully deleted ${path}`;
+    }
+    catch (error) {
+        throw new Error(`Failed to delete file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};

package/dist/tools/fileOps.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Tool: move_file
+ * Move or rename files safely
+ */
+import { z } from 'zod';
+export declare const name = "move_file";
+export declare const description = "Move or rename a file from source to destination. Creates destination directory if it does not exist.";
+export declare const permission: "write";
+export declare const schema: z.ZodObject<{
+    source: z.ZodString;
+    destination: z.ZodString;
+    overwrite: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    overwrite: boolean;
+    source: string;
+    destination: string;
+}, {
+    source: string;
+    destination: string;
+    overwrite?: boolean | undefined;
+}>;
+export declare const execute: (args: Record<string, unknown>) => Promise<string>;

package/dist/tools/fileOps.js

@@ -0,0 +1,43 @@
+/**
+ * Tool: move_file
+ * Move or rename files safely
+ */
+import { rename, stat, mkdir } from 'fs/promises';
+import { resolve, dirname } from 'path';
+import { z } from 'zod';
+import { existsSync } from 'fs';
+export const name = 'move_file';
+export const description = 'Move or rename a file from source to destination. Creates destination directory if it does not exist.';
+export const permission = 'write';
+export const schema = z.object({
+    source: z.string().describe('Source file path'),
+    destination: z.string().describe('Destination file path'),
+    overwrite: z.boolean().optional().default(false).describe('Overwrite if destination exists')
+});
+export const execute = async (args) => {
+    const { source, destination, overwrite } = schema.parse(args);
+    const srcPath = resolve(source);
+    const destPath = resolve(destination);
+    try {
+        // Check if source exists
+        await stat(srcPath);
+    }
+    catch {
+        throw new Error(`Source file not found: ${srcPath}`);
+    }
+    // Check if destination exists
+    if (existsSync(destPath) && !overwrite) {
+        throw new Error(`Destination already exists: ${destPath}. Set overwrite=true to force.`);
+    }
+    // Ensure destination directory exists
+    await mkdir(dirname(destPath), { recursive: true });
+    try {
+        await rename(srcPath, destPath);
+        return `Successfully moved ${source} to ${destination}`;
+    }
+    catch (error) {
+        // If cross-device link error (EXDEV), we might need copy+unlink, but Node's rename usually handles this or throws.
+        // For simplicity in this tool, we report the error.
+        throw new Error(`Failed to move file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};

package/dist/tools/file_ops.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Tool: move_file
+ * Move or rename files safely
+ */
+import { z } from 'zod';
+export declare const name = "move_file";
+export declare const description = "Move or rename a file from source to destination. Creates destination directory if it does not exist.";
+export declare const permission: "write";
+export declare const schema: z.ZodObject<{
+    source: z.ZodString;
+    destination: z.ZodString;
+    overwrite: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    overwrite: boolean;
+    source: string;
+    destination: string;
+}, {
+    source: string;
+    destination: string;
+    overwrite?: boolean | undefined;
+}>;
+export declare const execute: (args: Record<string, unknown>) => Promise<string>;

package/dist/tools/file_ops.js

@@ -0,0 +1,43 @@
+/**
+ * Tool: move_file
+ * Move or rename files safely
+ */
+import { rename, stat, mkdir } from 'fs/promises';
+import { resolve, dirname } from 'path';
+import { z } from 'zod';
+import { existsSync } from 'fs';
+export const name = 'move_file';
+export const description = 'Move or rename a file from source to destination. Creates destination directory if it does not exist.';
+export const permission = 'write';
+export const schema = z.object({
+    source: z.string().describe('Source file path'),
+    destination: z.string().describe('Destination file path'),
+    overwrite: z.boolean().optional().default(false).describe('Overwrite if destination exists')
+});
+export const execute = async (args) => {
+    const { source, destination, overwrite } = schema.parse(args);
+    const srcPath = resolve(source);
+    const destPath = resolve(destination);
+    try {
+        // Check if source exists
+        await stat(srcPath);
+    }
+    catch {
+        throw new Error(`Source file not found: ${srcPath}`);
+    }
+    // Check if destination exists
+    if (existsSync(destPath) && !overwrite) {
+        throw new Error(`Destination already exists: ${destPath}. Set overwrite=true to force.`);
+    }
+    // Ensure destination directory exists
+    await mkdir(dirname(destPath), { recursive: true });
+    try {
+        await rename(srcPath, destPath);
+        return `Successfully moved ${source} to ${destination}`;
+    }
+    catch (error) {
+        // If cross-device link error (EXDEV), we might need copy+unlink, but Node's rename usually handles this or throws.
+        // For simplicity in this tool, we report the error.
+        throw new Error(`Failed to move file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};

package/dist/tools/grep.d.ts

@@ -20,12 +20,12 @@ export declare const inputSchema: z.ZodObject<{
     contextLines: number;
     filesOnly: boolean;
     includeHidden: boolean;
-    glob?: string | undefined;
     path?: string | undefined;
+    glob?: string | undefined;
 }, {
     pattern: string;
-    glob?: string | undefined;
     path?: string | undefined;
+    glob?: string | undefined;
     ignoreCase?: boolean | undefined;
     maxResults?: number | undefined;
     contextLines?: number | undefined;