digital-tools 2.1.1 → 2.3.0

package/dist/tools/system.js

@@ -0,0 +1,752 @@
+/**
+ * System Tools - Filesystem, Git, and Shell operations
+ *
+ * Integrates fsx.do, gitx.do, and bashx.do primitives for the dotdo ecosystem.
+ * These tools provide edge-compatible filesystem, git, and bash operations
+ * that work in Cloudflare Workers and Durable Objects.
+ *
+ * @packageDocumentation
+ */
+import { defineTool } from '../define.js';
+// ============================================================================
+// Filesystem Tools (fsx.do integration)
+// ============================================================================
+/**
+ * Read file contents from the virtual filesystem
+ */
+export const fsRead = defineTool({
+    id: 'system.fs.read',
+    name: 'Read File',
+    description: 'Read contents of a file from the virtual filesystem (fsx.do)',
+    category: 'system',
+    subcategory: 'filesystem',
+    input: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to the file to read' },
+            encoding: {
+                type: 'string',
+                description: 'Encoding for the file content',
+                enum: ['utf-8', 'binary', 'base64'],
+                default: 'utf-8',
+            },
+        },
+        required: ['path'],
+    },
+    handler: async (input) => {
+        // Placeholder - actual implementation will use @dotdo/fsx
+        // In production, this connects to the fsx.do Durable Object
+        const encoding = input.encoding || 'utf-8';
+        return {
+            content: `[fsx.do] Content of ${input.path}`,
+            size: 0,
+            encoding,
+        };
+    },
+    options: {
+        audience: 'both',
+        tags: ['fs', 'read', 'file', 'fsx'],
+        idempotent: true,
+    },
+});
+/**
+ * Write content to a file in the virtual filesystem
+ */
+export const fsWrite = defineTool({
+    id: 'system.fs.write',
+    name: 'Write File',
+    description: 'Write content to a file in the virtual filesystem (fsx.do)',
+    category: 'system',
+    subcategory: 'filesystem',
+    input: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to write the file' },
+            content: { type: 'string', description: 'Content to write' },
+            encoding: {
+                type: 'string',
+                description: 'Encoding for the content',
+                enum: ['utf-8', 'binary', 'base64'],
+                default: 'utf-8',
+            },
+            createDirs: {
+                type: 'boolean',
+                description: 'Create parent directories if they do not exist',
+                default: true,
+            },
+        },
+        required: ['path', 'content'],
+    },
+    handler: async (input) => {
+        // Placeholder - actual implementation will use @dotdo/fsx
+        return {
+            success: true,
+            path: input.path,
+            size: input.content.length,
+        };
+    },
+    options: {
+        audience: 'both',
+        tags: ['fs', 'write', 'file', 'fsx'],
+        permissions: [{ type: 'write', resource: 'filesystem' }],
+    },
+});
+/**
+ * List directory contents
+ */
+export const fsList = defineTool({
+    id: 'system.fs.list',
+    name: 'List Directory',
+    description: 'List contents of a directory in the virtual filesystem (fsx.do)',
+    category: 'system',
+    subcategory: 'filesystem',
+    input: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Directory path to list' },
+            recursive: { type: 'boolean', description: 'List recursively', default: false },
+            pattern: { type: 'string', description: 'Glob pattern to filter results' },
+        },
+        required: ['path'],
+    },
+    handler: async (input) => {
+        // Placeholder - actual implementation will use @dotdo/fsx
+        return {
+            entries: [],
+            count: 0,
+        };
+    },
+    options: {
+        audience: 'both',
+        tags: ['fs', 'list', 'directory', 'fsx'],
+        idempotent: true,
+    },
+});
+/**
+ * Delete a file or directory
+ */
+export const fsDelete = defineTool({
+    id: 'system.fs.delete',
+    name: 'Delete File/Directory',
+    description: 'Delete a file or directory from the virtual filesystem (fsx.do)',
+    category: 'system',
+    subcategory: 'filesystem',
+    input: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to delete' },
+            recursive: { type: 'boolean', description: 'Delete directories recursively', default: false },
+        },
+        required: ['path'],
+    },
+    handler: async (input) => {
+        // Placeholder - actual implementation will use @dotdo/fsx
+        return {
+            success: true,
+            path: input.path,
+            deleted: 1,
+        };
+    },
+    options: {
+        audience: 'both',
+        tags: ['fs', 'delete', 'remove', 'fsx'],
+        permissions: [{ type: 'write', resource: 'filesystem' }],
+        requiresConfirmation: true,
+    },
+});
+/**
+ * Search files using glob patterns
+ */
+export const fsGlob = defineTool({
+    id: 'system.fs.glob',
+    name: 'Glob Search',
+    description: 'Search for files using glob patterns (fsx.do)',
+    category: 'system',
+    subcategory: 'filesystem',
+    input: {
+        type: 'object',
+        properties: {
+            pattern: { type: 'string', description: 'Glob pattern (e.g., "**/*.ts")' },
+            cwd: { type: 'string', description: 'Working directory for the search' },
+        },
+        required: ['pattern'],
+    },
+    handler: async (input) => {
+        // Placeholder - actual implementation will use @dotdo/fsx
+        return {
+            matches: [],
+            count: 0,
+        };
+    },
+    options: {
+        audience: 'both',
+        tags: ['fs', 'glob', 'search', 'fsx'],
+        idempotent: true,
+    },
+});
+/**
+ * Search file contents using grep
+ */
+export const fsGrep = defineTool({
+    id: 'system.fs.grep',
+    name: 'Grep Search',
+    description: 'Search file contents using regular expressions (fsx.do)',
+    category: 'system',
+    subcategory: 'filesystem',
+    input: {
+        type: 'object',
+        properties: {
+            pattern: { type: 'string', description: 'Search pattern (regex)' },
+            path: { type: 'string', description: 'Path to search in' },
+            recursive: { type: 'boolean', description: 'Search recursively', default: true },
+            ignoreCase: { type: 'boolean', description: 'Case-insensitive search', default: false },
+        },
+        required: ['pattern'],
+    },
+    handler: async (input) => {
+        // Placeholder - actual implementation will use @dotdo/fsx
+        return {
+            matches: [],
+            count: 0,
+        };
+    },
+    options: {
+        audience: 'both',
+        tags: ['fs', 'grep', 'search', 'regex', 'fsx'],
+        idempotent: true,
+    },
+});
+// ============================================================================
+// Git Tools (gitx.do integration)
+// ============================================================================
+/**
+ * Initialize a git repository
+ */
+export const gitInit = defineTool({
+    id: 'system.git.init',
+    name: 'Git Init',
+    description: 'Initialize a new git repository (gitx.do)',
+    category: 'development',
+    subcategory: 'git',
+    input: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path for the repository' },
+            bare: { type: 'boolean', description: 'Create a bare repository', default: false },
+        },
+    },
+    handler: async (input) => {
+        // Placeholder - actual implementation will use @dotdo/gitx
+        return {
+            success: true,
+            path: input.path || '.',
+        };
+    },
+    options: {
+        audience: 'both',
+        tags: ['git', 'init', 'repository', 'gitx'],
+        permissions: [{ type: 'write', resource: 'git' }],
+    },
+});
+/**
+ * Clone a git repository
+ */
+export const gitClone = defineTool({
+    id: 'system.git.clone',
+    name: 'Git Clone',
+    description: 'Clone a git repository (gitx.do)',
+    category: 'development',
+    subcategory: 'git',
+    input: {
+        type: 'object',
+        properties: {
+            url: { type: 'string', description: 'Repository URL to clone' },
+            path: { type: 'string', description: 'Local path for the clone' },
+            branch: { type: 'string', description: 'Branch to checkout' },
+            depth: { type: 'number', description: 'Shallow clone depth' },
+        },
+        required: ['url'],
+    },
+    handler: async (input) => {
+        // Placeholder - actual implementation will use @dotdo/gitx
+        return {
+            success: true,
+            path: input.path || '.',
+            branch: input.branch || 'main',
+        };
+    },
+    options: {
+        audience: 'both',
+        tags: ['git', 'clone', 'repository', 'gitx'],
+        permissions: [{ type: 'write', resource: 'git' }],
+    },
+});
+/**
+ * Get git repository status
+ */
+export const gitStatus = defineTool({
+    id: 'system.git.status',
+    name: 'Git Status',
+    description: 'Get the status of a git repository (gitx.do)',
+    category: 'development',
+    subcategory: 'git',
+    input: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Repository path' },
+        },
+    },
+    handler: async (input) => {
+        // Placeholder - actual implementation will use @dotdo/gitx
+        return {
+            branch: 'main',
+            clean: true,
+            staged: [],
+            modified: [],
+            untracked: [],
+            ahead: 0,
+            behind: 0,
+        };
+    },
+    options: {
+        audience: 'both',
+        tags: ['git', 'status', 'gitx'],
+        idempotent: true,
+    },
+});
+/**
+ * Stage files for commit
+ */
+export const gitAdd = defineTool({
+    id: 'system.git.add',
+    name: 'Git Add',
+    description: 'Stage files for commit (gitx.do)',
+    category: 'development',
+    subcategory: 'git',
+    input: {
+        type: 'object',
+        properties: {
+            files: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Files to stage (use "." for all)',
+            },
+            path: { type: 'string', description: 'Repository path' },
+        },
+        required: ['files'],
+    },
+    handler: async (input) => {
+        // Placeholder - actual implementation will use @dotdo/gitx
+        return {
+            success: true,
+            staged: input.files,
+        };
+    },
+    options: {
+        audience: 'both',
+        tags: ['git', 'add', 'stage', 'gitx'],
+        permissions: [{ type: 'write', resource: 'git' }],
+    },
+});
+/**
+ * Create a commit
+ */
+export const gitCommit = defineTool({
+    id: 'system.git.commit',
+    name: 'Git Commit',
+    description: 'Create a new commit (gitx.do)',
+    category: 'development',
+    subcategory: 'git',
+    input: {
+        type: 'object',
+        properties: {
+            message: { type: 'string', description: 'Commit message' },
+            path: { type: 'string', description: 'Repository path' },
+            author: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string' },
+                    email: { type: 'string' },
+                },
+                description: 'Commit author',
+            },
+        },
+        required: ['message'],
+    },
+    handler: async (input) => {
+        // Placeholder - actual implementation will use @dotdo/gitx
+        return {
+            success: true,
+            sha: 'abc1234',
+            message: input.message,
+        };
+    },
+    options: {
+        audience: 'both',
+        tags: ['git', 'commit', 'gitx'],
+        permissions: [{ type: 'write', resource: 'git' }],
+    },
+});
+/**
+ * Get commit log
+ */
+export const gitLog = defineTool({
+    id: 'system.git.log',
+    name: 'Git Log',
+    description: 'Get commit history (gitx.do)',
+    category: 'development',
+    subcategory: 'git',
+    input: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Repository path' },
+            limit: { type: 'number', description: 'Maximum number of commits', default: 10 },
+            branch: { type: 'string', description: 'Branch to get log from' },
+        },
+    },
+    handler: async (input) => {
+        // Placeholder - actual implementation will use @dotdo/gitx
+        return {
+            commits: [],
+        };
+    },
+    options: {
+        audience: 'both',
+        tags: ['git', 'log', 'history', 'gitx'],
+        idempotent: true,
+    },
+});
+/**
+ * Show diff between commits or working tree
+ */
+export const gitDiff = defineTool({
+    id: 'system.git.diff',
+    name: 'Git Diff',
+    description: 'Show differences between commits or working tree (gitx.do)',
+    category: 'development',
+    subcategory: 'git',
+    input: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Repository path' },
+            from: { type: 'string', description: 'From commit/ref' },
+            to: { type: 'string', description: 'To commit/ref' },
+            file: { type: 'string', description: 'Specific file to diff' },
+        },
+    },
+    handler: async (input) => {
+        // Placeholder - actual implementation will use @dotdo/gitx
+        return {
+            diff: '',
+            additions: 0,
+            deletions: 0,
+            files: [],
+        };
+    },
+    options: {
+        audience: 'both',
+        tags: ['git', 'diff', 'gitx'],
+        idempotent: true,
+    },
+});
+/**
+ * Checkout a branch or commit
+ */
+export const gitCheckout = defineTool({
+    id: 'system.git.checkout',
+    name: 'Git Checkout',
+    description: 'Checkout a branch or commit (gitx.do)',
+    category: 'development',
+    subcategory: 'git',
+    input: {
+        type: 'object',
+        properties: {
+            ref: { type: 'string', description: 'Branch, tag, or commit to checkout' },
+            path: { type: 'string', description: 'Repository path' },
+            create: { type: 'boolean', description: 'Create new branch (-b flag)', default: false },
+        },
+        required: ['ref'],
+    },
+    handler: async (input) => {
+        // Placeholder - actual implementation will use @dotdo/gitx
+        return {
+            success: true,
+            ref: input.ref,
+        };
+    },
+    options: {
+        audience: 'both',
+        tags: ['git', 'checkout', 'branch', 'gitx'],
+        permissions: [{ type: 'write', resource: 'git' }],
+    },
+});
+/**
+ * Push commits to remote
+ */
+export const gitPush = defineTool({
+    id: 'system.git.push',
+    name: 'Git Push',
+    description: 'Push commits to a remote repository (gitx.do)',
+    category: 'development',
+    subcategory: 'git',
+    input: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Repository path' },
+            remote: { type: 'string', description: 'Remote name', default: 'origin' },
+            branch: { type: 'string', description: 'Branch to push' },
+            force: { type: 'boolean', description: 'Force push', default: false },
+        },
+    },
+    handler: async (input) => {
+        // Placeholder - actual implementation will use @dotdo/gitx
+        return {
+            success: true,
+            remote: input.remote || 'origin',
+            branch: input.branch || 'main',
+            commits: 0,
+        };
+    },
+    options: {
+        audience: 'both',
+        tags: ['git', 'push', 'remote', 'gitx'],
+        permissions: [{ type: 'write', resource: 'git' }],
+        requiresConfirmation: true,
+    },
+});
+/**
+ * Pull commits from remote
+ */
+export const gitPull = defineTool({
+    id: 'system.git.pull',
+    name: 'Git Pull',
+    description: 'Pull commits from a remote repository (gitx.do)',
+    category: 'development',
+    subcategory: 'git',
+    input: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Repository path' },
+            remote: { type: 'string', description: 'Remote name', default: 'origin' },
+            branch: { type: 'string', description: 'Branch to pull' },
+            rebase: { type: 'boolean', description: 'Rebase instead of merge', default: false },
+        },
+    },
+    handler: async (input) => {
+        // Placeholder - actual implementation will use @dotdo/gitx
+        return {
+            success: true,
+            remote: input.remote || 'origin',
+            branch: input.branch || 'main',
+            commits: 0,
+            conflicts: [],
+        };
+    },
+    options: {
+        audience: 'both',
+        tags: ['git', 'pull', 'remote', 'gitx'],
+        permissions: [{ type: 'write', resource: 'git' }],
+    },
+});
+// ============================================================================
+// Shell/Bash Tools (bashx.do integration)
+// ============================================================================
+/**
+ * Execute a bash command with AI-enhanced safety
+ */
+export const bashExec = defineTool({
+    id: 'system.bash.exec',
+    name: 'Execute Bash Command',
+    description: 'Execute a bash command with AI-enhanced safety and intent understanding (bashx.do)',
+    category: 'system',
+    subcategory: 'shell',
+    input: {
+        type: 'object',
+        properties: {
+            command: { type: 'string', description: 'Command to execute' },
+            cwd: { type: 'string', description: 'Working directory' },
+            env: {
+                type: 'object',
+                additionalProperties: { type: 'string' },
+                description: 'Environment variables',
+            },
+            timeout: { type: 'number', description: 'Timeout in milliseconds', default: 30000 },
+            stdin: { type: 'string', description: 'Standard input to provide' },
+        },
+        required: ['command'],
+    },
+    handler: async (input) => {
+        // Placeholder - actual implementation will use bashx.do
+        // bashx.do provides:
+        // - AI safety analysis (warns about destructive commands)
+        // - Intent understanding (suggests corrections)
+        // - Intelligent error recovery
+        return {
+            stdout: `[bashx.do] Would execute: ${input.command}`,
+            stderr: '',
+            exitCode: 0,
+            duration: 0,
+        };
+    },
+    options: {
+        audience: 'both',
+        tags: ['bash', 'shell', 'exec', 'command', 'bashx'],
+        permissions: [{ type: 'execute', resource: 'shell' }],
+        requiresConfirmation: true,
+        securityLevel: 'restricted',
+    },
+});
+/**
+ * Analyze command safety before execution
+ */
+export const bashAnalyze = defineTool({
+    id: 'system.bash.analyze',
+    name: 'Analyze Bash Command',
+    description: 'Analyze a bash command for safety using AI (bashx.do)',
+    category: 'system',
+    subcategory: 'shell',
+    input: {
+        type: 'object',
+        properties: {
+            command: { type: 'string', description: 'Command to analyze' },
+        },
+        required: ['command'],
+    },
+    handler: async (input) => {
+        // Placeholder - actual implementation will use bashx.do AI analysis
+        // Detect patterns like:
+        // - rm -rf / (destructive)
+        // - chmod 777 (security risk)
+        // - curl | bash (execution risk)
+        const warnings = [];
+        let riskLevel = 'low';
+        if (input.command.includes('rm -rf')) {
+            warnings.push('Recursive force delete detected');
+            riskLevel = 'high';
+        }
+        if (input.command.includes('chmod 777')) {
+            warnings.push('Overly permissive file permissions');
+            riskLevel = 'medium';
+        }
+        if (input.command.includes('| bash') || input.command.includes('| sh')) {
+            warnings.push('Pipe to shell execution detected');
+            riskLevel = 'high';
+        }
+        return {
+            safe: warnings.length === 0,
+            riskLevel,
+            warnings,
+            suggestions: [],
+            intent: `Execute: ${input.command}`,
+        };
+    },
+    options: {
+        audience: 'both',
+        tags: ['bash', 'safety', 'analyze', 'bashx'],
+        idempotent: true,
+    },
+});
+/**
+ * Execute a script file
+ */
+export const bashScript = defineTool({
+    id: 'system.bash.script',
+    name: 'Execute Bash Script',
+    description: 'Execute a bash script with arguments (bashx.do)',
+    category: 'system',
+    subcategory: 'shell',
+    input: {
+        type: 'object',
+        properties: {
+            script: { type: 'string', description: 'Script content or path' },
+            args: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Script arguments',
+            },
+            cwd: { type: 'string', description: 'Working directory' },
+            env: {
+                type: 'object',
+                additionalProperties: { type: 'string' },
+                description: 'Environment variables',
+            },
+        },
+        required: ['script'],
+    },
+    handler: async (input) => {
+        // Placeholder - actual implementation will use bashx.do
+        return {
+            stdout: `[bashx.do] Would execute script with args: ${input.args?.join(' ') || '(none)'}`,
+            stderr: '',
+            exitCode: 0,
+        };
+    },
+    options: {
+        audience: 'both',
+        tags: ['bash', 'script', 'execute', 'bashx'],
+        permissions: [{ type: 'execute', resource: 'shell' }],
+        requiresConfirmation: true,
+        securityLevel: 'restricted',
+    },
+});
+/**
+ * Get environment information
+ */
+export const bashEnv = defineTool({
+    id: 'system.bash.env',
+    name: 'Get Environment',
+    description: 'Get shell environment information (bashx.do)',
+    category: 'system',
+    subcategory: 'shell',
+    input: {
+        type: 'object',
+        properties: {
+            filter: { type: 'string', description: 'Filter variables by prefix' },
+        },
+    },
+    handler: async (input) => {
+        // Placeholder - actual implementation will use bashx.do
+        return {
+            variables: {},
+            shell: '/bin/bash',
+            cwd: '/',
+            user: 'unknown',
+        };
+    },
+    options: {
+        audience: 'both',
+        tags: ['bash', 'environment', 'env', 'bashx'],
+        idempotent: true,
+    },
+});
+// ============================================================================
+// Tool Collections
+// ============================================================================
+/**
+ * All filesystem tools (fsx.do)
+ */
+export const fsxTools = [fsRead, fsWrite, fsList, fsDelete, fsGlob, fsGrep];
+/**
+ * All git tools (gitx.do)
+ */
+export const gitxTools = [
+    gitInit,
+    gitClone,
+    gitStatus,
+    gitAdd,
+    gitCommit,
+    gitLog,
+    gitDiff,
+    gitCheckout,
+    gitPush,
+    gitPull,
+];
+/**
+ * All bash tools (bashx.do)
+ */
+export const bashxTools = [bashExec, bashAnalyze, bashScript, bashEnv];
+/**
+ * All system tools (fsx + gitx + bashx)
+ */
+export const systemTools = [...fsxTools, ...gitxTools, ...bashxTools];
+//# sourceMappingURL=system.js.map