@tianmucreations/jeeves 0.2.0

package/dist/tools/index.js

@@ -0,0 +1,106 @@
+import { tool } from 'ai';
+import { session } from '../state/session.js';
+import { requestApproval } from '../agent/permissions.js';
+import { readFileSchema, runReadFile } from './readFile.js';
+import { writeFileSchema, runWriteFile } from './writeFile.js';
+import { listDirSchema, runListDir } from './listDir.js';
+import { runBashSchema, runRunBash } from './runBash.js';
+// Assumption: every tool result is capped to keep huge outputs from flooding the conversation.
+const MAX_RESULT_CHARS = 150_000;
+function truncate(text) {
+    return text.length > MAX_RESULT_CHARS ? text.slice(0, MAX_RESULT_CHARS) + '\n[output truncated]' : text;
+}
+function describeError(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}
+// Plain-English one-line failure text for the transcript; the model still receives
+// the full technical message so it can react.
+export function plainToolFailure(error) {
+    const raw = describeError(error);
+    const text = raw.toLowerCase();
+    if (text.includes('enoent'))
+        return 'file or folder not found';
+    if (text.includes('eacces') || text.includes('eperm'))
+        return 'permission denied';
+    if (text.includes('timed out') || text.includes('etimedout') || text.includes('stopped after'))
+        return 'took too long';
+    if (text.includes('binary file'))
+        return 'not a text file';
+    const firstLine = raw.split('\n')[0].trim();
+    return firstLine.length > 0 ? firstLine : 'failed';
+}
+function clip(text, max) {
+    return text.length > max ? text.slice(0, max - 1) + '…' : text;
+}
+function defineTool(config) {
+    return tool({
+        description: config.description,
+        inputSchema: config.schema,
+        execute: async (rawInput) => {
+            // The SDK validates before execute; parsing again keeps this layer strictly typed.
+            const input = config.schema.parse(rawInput);
+            const summary = config.summarize(input);
+            const lineId = session.addToolLine(config.name, summary, config.permission ? 'awaiting' : 'running');
+            if (config.permission) {
+                const approved = await requestApproval();
+                if (!approved) {
+                    session.updateToolLine(lineId, { state: 'declined' });
+                    throw new Error(`Permission denied by the user - ${config.name} ${summary} was not executed.`);
+                }
+                session.updateToolLine(lineId, { state: 'running' });
+            }
+            try {
+                const result = truncate(await config.run(input));
+                session.updateToolLine(lineId, { state: 'done', label: config.label(input, result) });
+                return result;
+            }
+            catch (error) {
+                session.updateToolLine(lineId, { state: 'failed', label: plainToolFailure(error) });
+                throw error;
+            }
+        },
+    });
+}
+export const TOOLS = {
+    readFile: defineTool({
+        name: 'readFile',
+        description: 'Read the contents of a text file at the given path.',
+        schema: readFileSchema,
+        permission: false,
+        summarize: (input) => input.path,
+        label: (input) => `Read ${input.path}`,
+        run: runReadFile,
+    }),
+    listDir: defineTool({
+        name: 'listDir',
+        description: 'List the files and folders in a directory, ignoring .gitignore rules. Set recursive to true to include subfolders.',
+        schema: listDirSchema,
+        permission: false,
+        summarize: (input) => input.path,
+        label: (input, result) => `Listed ${input.path} (${result.split('\n').length} items)`,
+        run: runListDir,
+    }),
+    writeFile: defineTool({
+        name: 'writeFile',
+        description: 'Write text content to a file, creating the file if it does not exist.',
+        schema: writeFileSchema,
+        permission: true,
+        summarize: (input) => `${input.path} (${input.content.length} characters)`,
+        label: () => 'Wrote 1 file',
+        run: runWriteFile,
+    }),
+    runBash: defineTool({
+        name: 'runBash',
+        description: 'Run a shell command and return its output.',
+        schema: runBashSchema,
+        permission: true,
+        summarize: (input) => clip(input.command, 60),
+        label: (input) => `Ran ${clip(input.command, 60)}`,
+        run: runRunBash,
+    }),
+};
+export function getTools() {
+    return TOOLS;
+}

package/dist/tools/listDir.js

@@ -0,0 +1,55 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import fg from 'fast-glob';
+import { z } from 'zod';
+import { resolveFromCwd } from '../platform/paths.js';
+export const listDirSchema = z.object({
+    path: z.string().describe('Directory to list'),
+    recursive: z.boolean().optional().describe('Include all subfolders'),
+});
+// Assumption: only the top-level .gitignore of the listed folder is honoured, and negation
+// rules (!) are not supported - typical project files use plain ignore rules only.
+// Glob patterns use forward slashes on every platform by design (fast-glob normalises them),
+// so these are not filesystem paths and never need path.sep.
+function ignorePatterns(dir) {
+    const patterns = ['**/.git', '**/.git/**', '**/node_modules', '**/node_modules/**'];
+    const gitignorePath = path.join(dir, '.gitignore');
+    if (!existsSync(gitignorePath))
+        return patterns;
+    const lines = readFileSync(gitignorePath, 'utf8').split('\n');
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (!line || line.startsWith('#') || line.startsWith('!'))
+            continue;
+        const anchored = line.startsWith('/');
+        const cleaned = line.replace(/^\//, '').replace(/\/+$/, '');
+        if (!cleaned)
+            continue;
+        if (anchored) {
+            patterns.push(cleaned, `${cleaned}/**`);
+        }
+        else {
+            patterns.push(`**/${cleaned}`, `**/${cleaned}/**`);
+        }
+    }
+    return patterns;
+}
+export async function runListDir(input) {
+    const dir = resolveFromCwd(input.path);
+    if (!existsSync(dir)) {
+        throw new Error('That folder does not exist.');
+    }
+    const entries = await fg(input.recursive ? ['**/*'] : ['*'], {
+        cwd: dir,
+        onlyFiles: false,
+        dot: false,
+        deep: input.recursive ? 8 : 1,
+        ignore: ignorePatterns(dir),
+    });
+    if (entries.length === 0)
+        return '(empty folder)';
+    const sorted = entries.sort();
+    const cap = 2000;
+    const shown = sorted.slice(0, cap).join('\n');
+    return sorted.length > cap ? `${shown}\n(and ${sorted.length - cap} more)` : shown;
+}

package/dist/tools/readFile.js

@@ -0,0 +1,15 @@
+import { readFile as fsReadFile } from 'node:fs/promises';
+import { z } from 'zod';
+import { resolveFromCwd } from '../platform/paths.js';
+export const readFileSchema = z.object({
+    path: z.string().describe('Path of the file to read, relative to the current folder or absolute'),
+});
+export async function runReadFile(input) {
+    const resolved = resolveFromCwd(input.path);
+    const contents = await fsReadFile(resolved, 'utf8');
+    // Guard against feeding binary files into the conversation as gibberish.
+    if (contents.slice(0, 1000).includes('\u0000')) {
+        throw new Error('This looks like a binary file; it cannot be read as text.');
+    }
+    return contents;
+}

package/dist/tools/runBash.js

@@ -0,0 +1,22 @@
+import { execa } from 'execa';
+import { z } from 'zod';
+import { getShell } from '../platform/shell.js';
+export const runBashSchema = z.object({
+    command: z.string().describe('The shell command to run'),
+});
+export async function runRunBash(input) {
+    const shell = getShell();
+    // Assumption: a two-minute cap stops a runaway command from hanging the session forever.
+    const result = await execa(shell.program, [shell.flag, input.command], {
+        reject: false,
+        timeout: 120_000,
+    });
+    const parts = [`$ ${input.command}`, `exit code: ${result.exitCode ?? 'unknown'}`];
+    if (result.timedOut === true)
+        parts.push('The command was stopped after 2 minutes.');
+    if (result.stdout)
+        parts.push(`stdout:\n${result.stdout}`);
+    if (result.stderr)
+        parts.push(`stderr:\n${result.stderr}`);
+    return parts.join('\n\n');
+}

package/dist/tools/writeFile.js

@@ -0,0 +1,15 @@
+import { mkdir, writeFile as fsWriteFile } from 'node:fs/promises';
+import path from 'node:path';
+import { z } from 'zod';
+import { resolveFromCwd } from '../platform/paths.js';
+export const writeFileSchema = z.object({
+    path: z.string().describe('Path of the file to write'),
+    content: z.string().describe('The complete text content for the file'),
+});
+export async function runWriteFile(input) {
+    const resolved = resolveFromCwd(input.path);
+    // Assumption: missing parent folders are created so new files can land in new folders.
+    await mkdir(path.dirname(resolved), { recursive: true });
+    await fsWriteFile(resolved, input.content, 'utf8');
+    return `Wrote ${input.content.length} characters to ${input.path}.`;
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@tianmucreations/jeeves",
+  "version": "0.2.0",
+  "description": "A clean terminal assistant. Plain English in, job done. Works with any model.",
+  "author": {
+    "name": "tianmucreations",
+    "url": "https://tianmucreations.com"
+  },
+  "homepage": "https://tianmucreations.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tianmucreations/jeeves.git"
+  },
+  "bugs": {
+    "url": "https://github.com/tianmucreations/jeeves/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "bin/",
+    "dist/",
+    "README.md"
+  ],
+  "type": "module",
+  "bin": {
+    "jeeves": "bin/jeeves"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "dev": "tsx src/index.tsx",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^4.0.54",
+    "@openrouter/ai-sdk-provider": "^3.0.0",
+    "ai": "^7.0.100",
+    "chalk": "^6.0.0",
+    "commander": "^15.0.0",
+    "conf": "^15.1.0",
+    "execa": "^10.0.1",
+    "fast-glob": "^3.3.3",
+    "fuse.js": "^7.5.0",
+    "ink": "^7.1.1",
+    "ink-spinner": "^5.0.0",
+    "keytar": "^7.9.0",
+    "node-notifier": "^10.0.1",
+    "react": "^19.3.0",
+    "signal-exit": "^3.0.7",
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
+    "@types/node": "^26.5.1",
+    "@types/node-notifier": "^8.0.5",
+    "@types/react": "^19.3.0",
+    "tsx": "^4.23.13",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.0"
+  }
+}