@shareai-lab/kode-sdk 1.0.0-beta.8 → 2.7.0

package/dist/tools/bash.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BashKill = exports.BashLogs = exports.BashRun = void 0;
-const processes = new Map();
-class BashRun {
-    constructor() {
-        this.name = 'bash_run';
-        this.description = 'Execute a bash command';
-        this.input_schema = {
-            type: 'object',
-            properties: {
-                cmd: { type: 'string', description: 'Command to execute' },
-                timeout_ms: { type: 'number', description: 'Timeout in milliseconds (default: 120000)' },
-                background: { type: 'boolean', description: 'Run in background and return shell_id' },
-            },
-            required: ['cmd'],
-        };
-    }
-    async exec(args, ctx) {
-        if (args.background) {
-            const id = `shell-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-            const promise = ctx.sandbox.exec(args.cmd, { timeoutMs: args.timeout_ms });
-            const proc = {
-                id,
-                cmd: args.cmd,
-                startTime: Date.now(),
-                promise,
-                stdout: '',
-                stderr: '',
-            };
-            processes.set(id, proc);
-            promise.then((result) => {
-                proc.code = result.code;
-                proc.stdout = result.stdout;
-                proc.stderr = result.stderr;
-            });
-            return `Background shell started: ${id}`;
-        }
-        else {
-            const result = await ctx.sandbox.exec(args.cmd, { timeoutMs: args.timeout_ms });
-            const output = [result.stdout, result.stderr].filter(Boolean).join('\n').trim();
-            return output || '(no output)';
-        }
-    }
-}
-exports.BashRun = BashRun;
-class BashLogs {
-    constructor() {
-        this.name = 'bash_logs';
-        this.description = 'Get output from a background bash shell';
-        this.input_schema = {
-            type: 'object',
-            properties: {
-                shell_id: { type: 'string', description: 'Shell ID from bash_run' },
-            },
-            required: ['shell_id'],
-        };
-    }
-    async exec(args, ctx) {
-        const proc = processes.get(args.shell_id);
-        if (!proc) {
-            throw new Error(`Shell not found: ${args.shell_id}`);
-        }
-        const isRunning = proc.code === undefined;
-        const status = isRunning ? 'running' : `completed (exit code ${proc.code})`;
-        const output = [proc.stdout, proc.stderr].filter(Boolean).join('\n').trim();
-        return `Shell ${args.shell_id}: ${status}\n${output || '(no output yet)'}`;
-    }
-}
-exports.BashLogs = BashLogs;
-class BashKill {
-    constructor() {
-        this.name = 'bash_kill';
-        this.description = 'Kill a background bash shell';
-        this.input_schema = {
-            type: 'object',
-            properties: {
-                shell_id: { type: 'string', description: 'Shell ID from Bash.Run' },
-            },
-            required: ['shell_id'],
-        };
-    }
-    async exec(args, ctx) {
-        const proc = processes.get(args.shell_id);
-        if (!proc) {
-            throw new Error(`Shell not found: ${args.shell_id}`);
-        }
-        processes.delete(args.shell_id);
-        return `Killed shell ${args.shell_id}`;
-    }
-}
-exports.BashKill = BashKill;

package/dist/tools/fs.d.ts

@@ -1,96 +0,0 @@
-import { ToolContext, ToolOutcome, HookDecision, PostHookResult } from '../core/types';
-import { Hooks } from '../core/hooks';
-export interface Tool {
-    name: string;
-    description: string;
-    input_schema: any;
-    exec(args: any, ctx: ToolContext): Promise<any>;
-    hooks?: Hooks;
-    permissionDetails?: (call: any, ctx: ToolContext) => any;
-}
-export declare class FsRead implements Tool {
-    name: string;
-    description: string;
-    input_schema: {
-        type: string;
-        properties: {
-            file: {
-                type: string;
-                description: string;
-            };
-            offset: {
-                type: string;
-                description: string;
-            };
-            limit: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-    };
-    exec(args: {
-        file: string;
-        offset?: number;
-        limit?: number;
-    }, ctx: ToolContext): Promise<any>;
-}
-export declare class FsWrite implements Tool {
-    name: string;
-    description: string;
-    input_schema: {
-        type: string;
-        properties: {
-            file: {
-                type: string;
-                description: string;
-            };
-            content: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-    };
-    exec(args: {
-        file: string;
-        content: string;
-    }, ctx: ToolContext): Promise<any>;
-}
-export declare class FsEdit implements Tool {
-    name: string;
-    description: string;
-    input_schema: {
-        type: string;
-        properties: {
-            file: {
-                type: string;
-                description: string;
-            };
-            old_string: {
-                type: string;
-                description: string;
-            };
-            new_string: {
-                type: string;
-                description: string;
-            };
-            replace_all: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-    };
-    exec(args: {
-        file: string;
-        old_string: string;
-        new_string: string;
-        replace_all?: boolean;
-    }, ctx: ToolContext): Promise<any>;
-}
-export declare function toolTune(tool: Tool, hooks: {
-    preToolUse?: (call: any, ctx: ToolContext) => HookDecision | Promise<HookDecision>;
-    postToolUse?: (outcome: ToolOutcome, ctx: ToolContext) => PostHookResult | Promise<PostHookResult>;
-    permissionDetails?: (call: any, ctx: ToolContext) => any;
-}): Tool;

package/dist/tools/fs.js

@@ -1,100 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FsEdit = exports.FsWrite = exports.FsRead = void 0;
-exports.toolTune = toolTune;
-class FsRead {
-    constructor() {
-        this.name = 'fs_read';
-        this.description = 'Read contents from a file';
-        this.input_schema = {
-            type: 'object',
-            properties: {
-                file: { type: 'string', description: 'Path to file' },
-                offset: { type: 'number', description: 'Line offset (optional)' },
-                limit: { type: 'number', description: 'Max lines to read (optional)' },
-            },
-            required: ['file'],
-        };
-    }
-    async exec(args, ctx) {
-        const content = await ctx.sandbox.fs.read(args.file);
-        const lines = content.split('\n');
-        const offset = args.offset || 0;
-        const limit = args.limit || lines.length;
-        const selected = lines.slice(offset, offset + limit);
-        return selected.join('\n');
-    }
-}
-exports.FsRead = FsRead;
-class FsWrite {
-    constructor() {
-        this.name = 'fs_write';
-        this.description = 'Write contents to a file (creates or overwrites)';
-        this.input_schema = {
-            type: 'object',
-            properties: {
-                file: { type: 'string', description: 'Path to file' },
-                content: { type: 'string', description: 'Content to write' },
-            },
-            required: ['file', 'content'],
-        };
-    }
-    async exec(args, ctx) {
-        await ctx.sandbox.fs.write(args.file, args.content);
-        const bytes = Buffer.byteLength(args.content, 'utf8');
-        return `Wrote ${bytes} bytes to ${args.file}`;
-    }
-}
-exports.FsWrite = FsWrite;
-class FsEdit {
-    constructor() {
-        this.name = 'fs_edit';
-        this.description = 'Edit a file by replacing old_string with new_string';
-        this.input_schema = {
-            type: 'object',
-            properties: {
-                file: { type: 'string', description: 'Path to file' },
-                old_string: { type: 'string', description: 'String to replace' },
-                new_string: { type: 'string', description: 'Replacement string' },
-                replace_all: { type: 'boolean', description: 'Replace all occurrences (default: false)' },
-            },
-            required: ['file', 'old_string', 'new_string'],
-        };
-    }
-    async exec(args, ctx) {
-        const content = await ctx.sandbox.fs.read(args.file);
-        if (args.replace_all) {
-            const updated = content.split(args.old_string).join(args.new_string);
-            await ctx.sandbox.fs.write(args.file, updated);
-            const count = content.split(args.old_string).length - 1;
-            return `Replaced ${count} occurrence(s) in ${args.file}`;
-        }
-        else {
-            const occurrences = content.split(args.old_string).length - 1;
-            if (occurrences === 0) {
-                throw new Error(`old_string not found in ${args.file}`);
-            }
-            if (occurrences > 1) {
-                throw new Error(`old_string appears ${occurrences} times; use replace_all=true or provide unique string`);
-            }
-            const updated = content.replace(args.old_string, args.new_string);
-            await ctx.sandbox.fs.write(args.file, updated);
-            return `Replaced 1 occurrence in ${args.file}`;
-        }
-    }
-}
-exports.FsEdit = FsEdit;
-function toolTune(tool, hooks) {
-    return {
-        name: tool.name,
-        description: tool.description,
-        input_schema: tool.input_schema,
-        exec: tool.exec.bind(tool),
-        hooks: {
-            ...tool.hooks,
-            preToolUse: hooks.preToolUse,
-            postToolUse: hooks.postToolUse,
-        },
-        permissionDetails: hooks.permissionDetails || tool.permissionDetails,
-    };
-}

package/dist/tools/task.d.ts

@@ -1,38 +0,0 @@
-import { ToolContext } from '../core/types';
-import { Tool } from './fs';
-export interface AgentTemplate {
-    id: string;
-    system?: string;
-    tools?: Tool[];
-    whenToUse?: string;
-}
-export declare class TaskRun implements Tool {
-    private subAgents;
-    name: string;
-    description: string;
-    input_schema: {
-        type: string;
-        properties: {
-            task: {
-                type: string;
-                description: string;
-            };
-            with: {
-                type: string;
-                description: string;
-            };
-            context: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-    };
-    constructor(subAgents: AgentTemplate[]);
-    exec(args: {
-        task: string;
-        with?: string;
-        context?: string;
-    }, ctx: ToolContext): Promise<any>;
-    private selectTemplate;
-}

package/dist/tools/task.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskRun = void 0;
-class TaskRun {
-    constructor(subAgents) {
-        this.subAgents = subAgents;
-        this.name = 'task_run';
-        this.description = 'Delegate a task to a sub-agent';
-        this.input_schema = {
-            type: 'object',
-            properties: {
-                task: { type: 'string', description: 'Task description for the sub-agent' },
-                with: { type: 'string', description: 'Template ID to use (optional, will auto-select if omitted)' },
-                context: { type: 'string', description: 'Additional context (optional)' },
-            },
-            required: ['task'],
-        };
-    }
-    async exec(args, ctx) {
-        // This will be implemented when Agent class is ready
-        // For now, return a placeholder
-        const template = args.with
-            ? this.subAgents.find((t) => t.id === args.with)
-            : this.selectTemplate(args.task);
-        if (!template) {
-            throw new Error(`Template not found: ${args.with || 'auto'}`);
-        }
-        return {
-            status: 'delegated',
-            template: template.id,
-            task: args.task,
-            note: 'Sub-agent execution will be implemented in Agent class',
-        };
-    }
-    selectTemplate(task) {
-        // Simple heuristic selection based on whenToUse hints
-        for (const template of this.subAgents) {
-            if (template.whenToUse && task.toLowerCase().includes(template.whenToUse.toLowerCase())) {
-                return template;
-            }
-        }
-        return this.subAgents[0];
-    }
-}
-exports.TaskRun = TaskRun;