hammerkit 1.26.0 → 1.27.0-next.1

package/dist/harness/opencode.js

@@ -0,0 +1,492 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchToSandbox = exports.createOpencodeTools = exports.createOpencodeV2Tools = exports.hammerkitOpencodeEntry = exports.hammerkitOpencodeV2Plugin = exports.OPENCODE_V2_LOCAL_TOOLS = exports.OPENCODE_V2_TOOLS = exports.loadHammerkitOpencodePlugin = exports.OPENCODE_TOOLS = exports.hammerkitOpencodePlugin = void 0;
+const fs_1 = require("fs");
+const minimatch_1 = require("minimatch");
+const os_1 = require("os");
+const path_1 = require("path");
+const url_1 = require("url");
+const connect_1 = require("./connect");
+const format_1 = require("./format");
+const sandbox_client_1 = require("./sandbox-client");
+const DEFAULT_READ_LINES = 2000;
+const LIST_LIMIT = 100;
+const SEARCH_LIMIT = 100;
+/**
+ * The tools of opencode on a hammerkit sandbox: `read`, `write`, `edit`, `apply_patch`,
+ * `bash`, `grep`, `glob` and `list` with the parameters of opencode's own, which a plugin replaces
+ * by registering tools of the same name, and `push`, which takes the work out as a branch. opencode resolves paths against its directory,
+ * which stands for the root of the sandbox. `schema` is the zod of opencode
+ * (`tool.schema` of `@opencode-ai/plugin`), so it reads the parameters as its own.
+ */
+function hammerkitOpencodePlugin(schema, settings = {}) {
+    return async (input) => ({ tool: createOpencodeTools(schema, lazySandbox(input.directory, settings)) });
+}
+exports.hammerkitOpencodePlugin = hammerkitOpencodePlugin;
+// the sandbox, connected on the first call of a tool and again after a failed connect
+function lazySandbox(directory, settings) {
+    const environment = settings.environment ?? (0, connect_1.getHarnessEnvironment)(directory);
+    const options = settings.options ?? (0, connect_1.harnessOptionsFromEnv)(environment.processEnvs);
+    let connecting;
+    return () => {
+        if (!connecting) {
+            connecting = settings.client ? settings.client() : (0, connect_1.connectSandbox)(environment, options);
+            connecting.catch(() => (connecting = undefined));
+        }
+        return connecting;
+    };
+}
+// the names of the tools of the plugin, which stand in for opencode's own
+exports.OPENCODE_TOOLS = ['read', 'write', 'edit', 'apply_patch', 'bash', 'grep', 'glob', 'push', 'list'];
+/**
+ * The plugin as the file `harness/opencode.ts` exports it: it takes the zod of opencode from
+ * `@opencode-ai/plugin`, found next to hammerkit or else in the opencode directories of the
+ * project and of the user, as a linked hammerkit does not see the packages of the project.
+ * Without it the tools still stand in for opencode's and refuse: opencode carries on without a
+ * plugin that fails, and its own tools would work on this machine. `load` is `import` of the file.
+ */
+function loadHammerkitOpencodePlugin(load, settings = {}) {
+    return async (input) => {
+        let schema;
+        let failure;
+        for (const specifier of ['@opencode-ai/plugin', ...opencodePluginFiles(input)]) {
+            try {
+                schema = (await load(specifier)).tool.schema;
+                break;
+            }
+            catch (e) {
+                failure = failure ?? e;
+            }
+        }
+        if (schema) {
+            return hammerkitOpencodePlugin(schema, settings)(input);
+        }
+        const message = `hammerkit's opencode plugin could not load @opencode-ai/plugin ` +
+            `(${failure instanceof Error ? failure.message : String(failure)}), so its tools refuse rather than ` +
+            'work on this machine: add "@opencode-ai/plugin" to the dependencies of .opencode/package.json';
+        const refusing = {
+            description: message,
+            args: {},
+            async execute() {
+                throw new Error(message);
+            },
+        };
+        return { tool: Object.fromEntries(exports.OPENCODE_TOOLS.map((name) => [name, refusing])) };
+    };
+}
+exports.loadHammerkitOpencodePlugin = loadHammerkitOpencodePlugin;
+// the entry of @opencode-ai/plugin in the opencode directories of the project and of the user
+function opencodePluginFiles(input) {
+    const config = process.env.XDG_CONFIG_HOME || (0, path_1.join)((0, os_1.homedir)(), '.config');
+    const directories = [input.directory, input.worktree, (0, path_1.join)(config, 'opencode')]
+        .filter((directory) => !!directory)
+        .flatMap((directory) => [(0, path_1.join)(directory, '.opencode'), directory]);
+    const files = [];
+    for (const directory of directories) {
+        for (let current = directory;; current = (0, path_1.dirname)(current)) {
+            const manifest = (0, path_1.join)(current, 'node_modules', '@opencode-ai', 'plugin', 'package.json');
+            if ((0, fs_1.existsSync)(manifest)) {
+                const entry = packageEntry(manifest);
+                if (entry && !files.includes(entry)) {
+                    files.push(entry);
+                }
+                break;
+            }
+            if ((0, path_1.dirname)(current) === current) {
+                break;
+            }
+        }
+    }
+    return files.map((file) => (0, url_1.pathToFileURL)(file).href);
+}
+function packageEntry(manifest) {
+    try {
+        const pkg = JSON.parse((0, fs_1.readFileSync)(manifest, 'utf8'));
+        const root = typeof pkg.exports === 'object' ? pkg.exports['.'] ?? pkg.exports : pkg.exports;
+        const entry = typeof root === 'string' ? root : root?.import ?? root?.default ?? pkg.module ?? pkg.main;
+        return typeof entry === 'string' ? (0, path_1.join)((0, path_1.dirname)(manifest), entry) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+// the names of the tools of the plugin on opencode 2, which stand in for its own
+exports.OPENCODE_V2_TOOLS = ['read', 'write', 'edit', 'patch', 'shell', 'glob', 'grep', 'push'];
+// the tools of opencode 2 that work on this machine and have no stand-in on a sandbox
+exports.OPENCODE_V2_LOCAL_TOOLS = [
+    'opencode_worktree_create',
+    'opencode_worktree_list',
+    'opencode_worktree_remove',
+];
+/**
+ * The plugin for opencode 2: the tools of {@link createOpencodeV2Tools} in place of opencode's own,
+ * and none of the worktree tools, which would make worktrees of this machine. opencode 2 takes a
+ * plugin as an object with an id and a setup, it needs no package of opencode.
+ */
+function hammerkitOpencodeV2Plugin(settings = {}) {
+    return {
+        id: 'hammerkit',
+        async setup(context) {
+            const directory = context.location.directory;
+            const tools = createOpencodeV2Tools(lazySandbox(directory, settings), directory);
+            await context.tool.transform((editor) => {
+                for (const tool of tools) {
+                    editor.add(tool);
+                }
+                for (const name of exports.OPENCODE_V2_LOCAL_TOOLS) {
+                    editor.remove(name);
+                }
+            });
+            // opencode describes the tool named shell anew for each request, as the shell of this machine
+            const shell = tools.find((tool) => tool.name === 'shell');
+            for (const name of ['context', 'compaction', 'generate']) {
+                await context.session.hook(name, (request) => {
+                    if (request.tools.shell) {
+                        request.tools.shell.description = shell.description;
+                    }
+                });
+            }
+        },
+    };
+}
+exports.hammerkitOpencodeV2Plugin = hammerkitOpencodeV2Plugin;
+/**
+ * The plugin as the file `harness/opencode.ts` exports it, for opencode 2 and for opencode 1, which
+ * takes the `server` of a plugin object: see {@link loadHammerkitOpencodePlugin}.
+ */
+function hammerkitOpencodeEntry(load, settings = {}) {
+    return { ...hammerkitOpencodeV2Plugin(settings), server: loadHammerkitOpencodePlugin(load, settings) };
+}
+exports.hammerkitOpencodeEntry = hammerkitOpencodeEntry;
+/**
+ * The tools of opencode 2 on a hammerkit sandbox, with the inputs of opencode's own: the tools of
+ * opencode 1 under their new names (`patch`, `shell`), paths as `path`, relative to `directory`
+ * or absolute below it. opencode 2 has no `list`, `read` lists a directory.
+ */
+function createOpencodeV2Tools(client, directory) {
+    const tools = opencodeTools(client);
+    const tool = (name, of, input, args, permission) => ({
+        name,
+        description: tools[of].description,
+        input,
+        options: permission ? { codemode: false, permission } : { codemode: false },
+        async execute(input, context) {
+            const done = await tools[of].execute(args(input), { directory, abort: context.signal });
+            return { content: typeof done === 'string' ? done : done.output };
+        },
+    });
+    const same = (input) => input;
+    return [
+        tool('read', 'read', object({
+            path: text('The file or directory to read, relative to the project or absolute'),
+            offset: count('The line number to start reading from (1-based)'),
+            limit: count(`The maximum number of lines to read (defaults to ${DEFAULT_READ_LINES})`),
+        }, ['path']), ({ path, ...rest }) => ({ filePath: path, ...rest })),
+        tool('write', 'write', object({ path: text('The file to write'), content: text('The content to write to the file') }, [
+            'path',
+            'content',
+        ]), ({ path, ...rest }) => ({ filePath: path, ...rest }), 'edit'),
+        tool('edit', 'edit', object({
+            path: text('The file to modify'),
+            oldString: text('The text to replace'),
+            newString: text('The text to replace it with (must be different from oldString)'),
+            replaceAll: flag('Replace all occurrences of oldString (default false)'),
+        }, ['path', 'oldString', 'newString']), ({ path, ...rest }) => ({ filePath: path, ...rest }), 'edit'),
+        tool('patch', 'apply_patch', object({ patchText: text('The full patch text that describes all changes to be made') }, ['patchText']), same, 'edit'),
+        tool('shell', 'bash', object({
+            command: text('The command to execute'),
+            workdir: text('The directory to run the command in, relative to the project. Use this instead of cd.'),
+            timeout: count('Timeout in milliseconds, 0 for the default of the shell task'),
+        }, ['command']), ({ timeout, ...rest }) => ({ ...rest, timeout: timeout || undefined })),
+        tool('glob', 'glob', object({
+            pattern: text('The glob pattern to match files against, like "**/*.ts"'),
+            path: text('The directory to search in, the project by default'),
+            limit: count(`The maximum number of files (default ${SEARCH_LIMIT})`),
+        }, ['pattern']), same),
+        tool('grep', 'grep', object({
+            pattern: text('The regular expression to search for in file contents'),
+            path: text('The directory to search in, the project by default'),
+            include: text('File pattern to include in the search (e.g. "*.js", "*.{ts,tsx}")'),
+            literal: flag('Search for the pattern as plain text'),
+            caseSensitive: flag('Match case (default true)'),
+            limit: count(`The maximum number of matching lines (default ${SEARCH_LIMIT})`),
+        }, ['pattern']), same),
+        tool('push', 'push', object({
+            branch: text('The branch to push to, created when it does not exist'),
+            message: text('The commit message'),
+        }, ['branch', 'message']), same),
+    ];
+}
+exports.createOpencodeV2Tools = createOpencodeV2Tools;
+const text = (description) => ({ type: 'string', description });
+const count = (description) => ({ type: 'integer', minimum: 0, description });
+const flag = (description) => ({ type: 'boolean', description });
+const object = (properties, required) => ({
+    type: 'object',
+    properties,
+    required,
+    additionalProperties: false,
+});
+function createOpencodeTools(z, client) {
+    return Object.fromEntries(Object.entries(opencodeTools(client)).map(([name, { args, ...tool }]) => [name, { ...tool, args: args(z) }]));
+}
+exports.createOpencodeTools = createOpencodeTools;
+function opencodeTools(client) {
+    const where = (context, path) => (0, sandbox_client_1.toSandboxPath)(context.directory, path ?? context.directory);
+    return inOrder({
+        read: {
+            description: 'Read a file or directory of the hammerkit sandbox. Lines come back numbered as `N: content`; ' +
+                `offset is the first line (1-indexed), limit the number of lines (default ${DEFAULT_READ_LINES}).`,
+            args: (z) => ({
+                filePath: z.string().describe('The absolute path to the file or directory to read'),
+                offset: z.number().int().min(0).optional().describe('The line number to start reading from (1-indexed)'),
+                limit: z.number().int().min(0).optional().describe('The maximum number of lines to read (defaults to 2000)'),
+            }),
+            async execute(args, context) {
+                const sandbox = await client();
+                const path = where(context, args.filePath);
+                const found = await sandbox.stat(path);
+                if (!found) {
+                    throw new Error(`File not found: ${args.filePath}`);
+                }
+                if (found.type === 'directory') {
+                    const tree = await sandbox.tree({ path: path || undefined, depth: 1, limit: 1000 });
+                    const prefix = path ? `${path}/` : '';
+                    return [
+                        `<path>${args.filePath}</path>`,
+                        '<type>directory</type>',
+                        '<entries>',
+                        (0, format_1.formatTree)(tree, prefix),
+                        '</entries>',
+                    ].join('\n');
+                }
+                const read = await sandbox.read(path, args.offset || 1, args.limit || DEFAULT_READ_LINES);
+                const last = read.nextOffset ? read.nextOffset - 1 : read.lines;
+                const footer = read.nextOffset
+                    ? `(Showing lines ${read.offset}-${last} of ${read.lines}. Use offset=${read.nextOffset} to continue.)`
+                    : `(End of file - total ${read.lines} lines)`;
+                return [
+                    `<path>${args.filePath}</path>`,
+                    '<type>file</type>',
+                    '<content>',
+                    (0, format_1.toColonNumbers)(read.content.replace(/\n$/, '')),
+                    '',
+                    footer,
+                    '</content>',
+                ].join('\n');
+            },
+        },
+        write: {
+            description: 'Write a file of the hammerkit sandbox, replacing it if it exists. Read a file before you overwrite it.',
+            args: (z) => ({
+                content: z.string().describe('The content to write to the file'),
+                filePath: z.string().describe('The absolute path to the file to write (must be absolute, not relative)'),
+            }),
+            async execute(args, context) {
+                const sandbox = await client();
+                await sandbox.writeRaw(where(context, args.filePath), args.content);
+                return 'Wrote file successfully.';
+            },
+        },
+        edit: {
+            description: 'Replace an exact string in a file of the hammerkit sandbox. oldString has to match exactly once, ' +
+                'unless replaceAll is set.',
+            args: (z) => ({
+                filePath: z.string().describe('The absolute path to the file to modify'),
+                oldString: z.string().describe('The text to replace'),
+                newString: z.string().describe('The text to replace it with (must be different from oldString)'),
+                replaceAll: z.boolean().optional().describe('Replace all occurrences of oldString (default false)'),
+            }),
+            async execute(args, context) {
+                if (args.oldString === args.newString) {
+                    throw new Error('No changes to apply: oldString and newString are identical.');
+                }
+                const sandbox = await client();
+                const path = where(context, args.filePath);
+                if (args.oldString === '') {
+                    // an empty oldString writes a new file, as opencode's edit does
+                    await sandbox.writeRaw(path, args.newString);
+                }
+                else {
+                    await sandbox.edit([
+                        {
+                            op: 'replace',
+                            path,
+                            old_string: args.oldString,
+                            new_string: args.newString,
+                            replace_all: args.replaceAll,
+                        },
+                    ]);
+                }
+                return 'Edit applied successfully.';
+            },
+        },
+        apply_patch: {
+            description: 'Apply a patch to the hammerkit sandbox: the `*** Begin Patch` format (Add File, Update File with ' +
+                '@@ context, Delete File, Move to) or a unified git diff. All files change or none.',
+            args: (z) => ({
+                patchText: z.string().describe('The full patch text that describes all changes to be made'),
+            }),
+            async execute(args, context) {
+                const sandbox = await client();
+                const files = await sandbox.edit([{ op: 'patch', patch: patchToSandbox(context.directory, args.patchText) }]);
+                const marks = { added: 'A', modified: 'M', deleted: 'D' };
+                return [
+                    'Success. Updated the following files:',
+                    ...files.map((file) => `${marks[file.change]} ${file.path}`),
+                ].join('\n');
+            },
+        },
+        bash: {
+            description: 'Run a shell command on the hammerkit sandbox, as the shell task of the published build file, in its ' +
+                'container. Commands run one at a time and nothing is kept between them but the files. They start in ' +
+                'the root of the sandbox, where the paths of this machine do not exist: give them relative paths.',
+            args: (z) => ({
+                command: z.string().describe('The command to execute'),
+                timeout: z.number().int().min(1).optional().describe('Optional timeout in milliseconds'),
+                workdir: z
+                    .string()
+                    .optional()
+                    .describe("The working directory to run the command in. Defaults to the current directory. Use this instead of 'cd' commands."),
+            }),
+            async execute(args, context) {
+                const sandbox = await client();
+                const ran = await sandbox.exec(args.command, where(context, args.workdir), {
+                    signal: context.abort,
+                    timeoutSeconds: args.timeout ? args.timeout / 1000 : undefined,
+                });
+                const lines = [(0, format_1.capOutput)(ran.output, 'narrow the command down, for example with grep, head or tail')];
+                if (ran.exitCode === null) {
+                    lines.push(`hammerkit: ${ran.result?.error ?? ran.run.error ?? `the run ended ${ran.run.state}`}`);
+                }
+                else if (ran.exitCode !== 0) {
+                    lines.push(`Exit code: ${ran.exitCode}`);
+                }
+                context.metadata?.({ metadata: { exit: ran.exitCode, run: ran.run.id } });
+                return lines.filter((line) => line.length > 0).join('\n\n') || '(no output)';
+            },
+        },
+        grep: {
+            description: 'Search the files of the hammerkit sandbox with a regular expression (ripgrep). Returns the matching ' +
+                'lines with their file and line number.',
+            args: (z) => ({
+                pattern: z.string().describe('The regex pattern to search for in file contents'),
+                path: z.string().optional().describe('The directory to search in. Defaults to the current working directory.'),
+                include: z.string().optional().describe('File pattern to include in the search (e.g. "*.js", "*.{ts,tsx}")'),
+            }),
+            async execute(args, context) {
+                const sandbox = await client();
+                const result = await sandbox.search({
+                    pattern: args.pattern,
+                    path: where(context, args.path) || undefined,
+                    glob: args.include ? [args.include] : undefined,
+                    fixed_strings: args.literal || undefined,
+                    i: args.caseSensitive === false || undefined,
+                    output_mode: 'content',
+                    head_limit: args.limit || SEARCH_LIMIT,
+                });
+                const matches = (result.matches ?? []).filter((match) => !match.context);
+                if (matches.length === 0) {
+                    return 'No files found';
+                }
+                const lines = [`Found ${result.exact ? '' : 'at least '}${result.total} matches`];
+                let file = '';
+                for (const match of matches) {
+                    if (match.path !== file) {
+                        file = match.path;
+                        lines.push('', `${(0, path_1.join)(context.directory, file)}:`);
+                    }
+                    lines.push(`  Line ${match.line}: ${match.text}`);
+                }
+                if (result.truncated) {
+                    lines.push('', '(Results are truncated. Consider using a more specific path or pattern.)');
+                }
+                return lines.join('\n');
+            },
+        },
+        glob: {
+            description: 'Find files of the hammerkit sandbox by a glob pattern like "**/*.js" or "src/**/*.ts".',
+            args: (z) => ({
+                pattern: z.string().describe('The glob pattern to match files against'),
+                path: z
+                    .string()
+                    .optional()
+                    .describe('The directory to search in. If not specified, the current working directory will be used.'),
+            }),
+            async execute(args, context) {
+                const sandbox = await client();
+                const tree = await sandbox.tree({
+                    path: where(context, args.path) || undefined,
+                    glob: args.pattern,
+                    limit: args.limit || SEARCH_LIMIT,
+                });
+                if (tree.entries.length === 0) {
+                    return 'No files found';
+                }
+                const lines = tree.entries.map((entry) => (0, path_1.join)(context.directory, ...entry.path.split('/')));
+                if (tree.truncated) {
+                    lines.push('', '(Results are truncated. Consider using a more specific path or pattern.)');
+                }
+                return lines.join('\n');
+            },
+        },
+        push: {
+            description: 'Commit the changes of the hammerkit sandbox and push them to a branch of its repository, for review. ' +
+                'The server pushes only to the branches its operator allows; the sandbox is at the pushed commit afterwards.',
+            args: (z) => ({
+                branch: z.string().describe('The branch to push to, created when it does not exist'),
+                message: z.string().describe('The commit message'),
+            }),
+            async execute(args) {
+                const pushed = await (await client()).push(args.branch, args.message);
+                return { title: `pushed to ${pushed.branch}`, output: `pushed ${pushed.commit} to ${pushed.branch}` };
+            },
+        },
+        // opencode's list: a tree of the first files below a directory
+        list: {
+            description: 'List the files and directories below a directory of the hammerkit sandbox, as a tree. Prefer glob and ' +
+                'grep when you know what you look for.',
+            args: (z) => ({
+                path: z
+                    .string()
+                    .optional()
+                    .describe('The absolute path to the directory to list (must be absolute, not relative)'),
+                ignore: z.array(z.string()).optional().describe('List of glob patterns to ignore'),
+            }),
+            async execute(args, context) {
+                const sandbox = await client();
+                const path = where(context, args.path);
+                const tree = await sandbox.tree({ path: path || undefined, depth: 64, limit: LIST_LIMIT });
+                const prefix = path ? `${path}/` : '';
+                const ignore = (args.ignore ?? []).map((pattern) => new minimatch_1.Minimatch(pattern, { dot: true, matchBase: true }));
+                const lines = [`${args.path ?? context.directory}/`];
+                for (const entry of tree.entries) {
+                    const relative = entry.path.startsWith(prefix) ? entry.path.slice(prefix.length) : entry.path;
+                    if (ignore.some((pattern) => pattern.match(relative))) {
+                        continue;
+                    }
+                    const parts = relative.split('/');
+                    lines.push(`${'  '.repeat(parts.length)}${parts[parts.length - 1]}${entry.type === 'directory' ? '/' : ''}`);
+                }
+                if (tree.truncated) {
+                    lines.push('', `(${tree.entries.length} of ${tree.total} shown, list a directory below it or use glob)`);
+                }
+                return lines.join('\n');
+            },
+        },
+    });
+}
+// opencode runs the tool calls of a step in parallel, they reach the sandbox one at a time in their order
+function inOrder(tools) {
+    const inTurn = (0, sandbox_client_1.oneAtATime)();
+    return Object.fromEntries(Object.entries(tools).map(([name, tool]) => [
+        name,
+        { ...tool, execute: (args, context) => inTurn(() => tool.execute(args, context)) },
+    ]));
+}
+// GPT models name the files of a patch by the absolute paths opencode shows them
+function patchToSandbox(root, patch) {
+    return patch.replace(/^(\*\*\* (?:Add File|Update File|Delete File|Move to): )(.*?)([ \t\r]*)$/gm, (line, head, path, end) => (0, path_1.isAbsolute)(path) ? `${head}${(0, sandbox_client_1.toSandboxPath)(root, path)}${end}` : line);
+}
+exports.patchToSandbox = patchToSandbox;
+//# sourceMappingURL=opencode.js.map