ai-discovery-manager-cli 0.1.0

package/dist/workspaceTools.js

@@ -0,0 +1,166 @@
+import { tool } from "@openai/agents";
+import { readdir, readFile, stat, writeFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+const MAX_READ_BYTES = 256 * 1024;
+const MAX_WRITE_BYTES = 1 * 1024 * 1024;
+const MAX_LIST_ENTRIES = 500;
+const IGNORED_FILENAMES = new Set([
+    "package-lock.json",
+    "pnpm-lock.yaml",
+    "yarn.lock",
+    "bun.lockb",
+    "npm-shrinkwrap.json",
+]);
+const IGNORED_SEGMENTS = new Set([".git", "node_modules"]);
+const SECRET_NAME_PATTERN = /(^\.env($|\.)|secret|credential|password|passwd|token|api[-_]?key|private[-_]?key|\.pem$|\.key$|\.p12$|\.pfx$)/i;
+export function resolveInside(workspaceRoot, relPath) {
+    const cleaned = (relPath ?? "").replace(/^[/\\]+/, "");
+    const resolved = path.resolve(workspaceRoot, cleaned);
+    const rel = path.relative(workspaceRoot, resolved);
+    if (rel === "") {
+        return resolved;
+    }
+    if (rel.startsWith("..") || path.isAbsolute(rel)) {
+        throw new Error(`Path escapes workspace: ${relPath}. Use paths relative to the workspace root.`);
+    }
+    return resolved;
+}
+export function toPosix(p) {
+    return p.split(path.sep).join("/");
+}
+function isIgnoredWorkspacePath(relPath) {
+    const posix = toPosix(relPath).replace(/^\.?\//, "");
+    const parts = posix.split("/").filter(Boolean);
+    if (parts.some((part) => IGNORED_SEGMENTS.has(part))) {
+        return true;
+    }
+    const filename = parts.at(-1) ?? "";
+    return IGNORED_FILENAMES.has(filename) || SECRET_NAME_PATTERN.test(filename);
+}
+function assertModelReadablePath(workspaceRoot, target, requested) {
+    const rel = toPosix(path.relative(workspaceRoot, target) || ".");
+    if (isIgnoredWorkspacePath(rel)) {
+        throw new Error(`Refusing to expose ignored or secret-like workspace path to the model: ${requested}`);
+    }
+}
+function looksBinary(buffer) {
+    const limit = Math.min(buffer.length, 8192);
+    for (let i = 0; i < limit; i += 1) {
+        if (buffer[i] === 0x00) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Read a UTF-8 text file from inside `workspaceRoot`, enforcing the same sandbox
+ * (`resolveInside`), size cap (`MAX_READ_BYTES`), and binary guard (`looksBinary`)
+ * as the `read_workspace_file` tool. Shared so the interactive `/read` command and
+ * the agent tool stay consistent.
+ */
+export async function readWorkspaceTextFile(workspaceRoot, relPath) {
+    const target = resolveInside(workspaceRoot, relPath);
+    assertModelReadablePath(workspaceRoot, target, relPath);
+    const info = await stat(target);
+    if (!info.isFile()) {
+        throw new Error(`Not a file: ${relPath}`);
+    }
+    const buffer = await readFile(target);
+    if (looksBinary(buffer)) {
+        throw new Error(`Refusing to read likely-binary file: ${relPath}. Tools only handle UTF-8 text.`);
+    }
+    const truncated = buffer.length > MAX_READ_BYTES;
+    const slice = truncated ? buffer.subarray(0, MAX_READ_BYTES) : buffer;
+    return {
+        path: toPosix(path.relative(workspaceRoot, target)),
+        bytes: info.size,
+        truncated,
+        content: slice.toString("utf8"),
+    };
+}
+export function createWorkspaceTools(options) {
+    const { workspaceRoot, allowWrites } = options;
+    const listTool = tool({
+        name: "list_workspace",
+        description: "List files and subdirectories in the research workspace. Pass a relative path (default: workspace root). Returns entries with name, type (file|dir), and size in bytes for files.",
+        parameters: z.object({
+            path: z
+                .string()
+                .describe("Relative path inside the workspace. Use '' or '.' for the workspace root.")
+                .default("."),
+        }),
+        async execute({ path: relPath }) {
+            const target = resolveInside(workspaceRoot, relPath || ".");
+            assertModelReadablePath(workspaceRoot, target, relPath || ".");
+            const info = await stat(target);
+            if (!info.isDirectory()) {
+                throw new Error(`Not a directory: ${relPath}`);
+            }
+            const entries = await readdir(target, { withFileTypes: true });
+            const visibleEntries = entries.filter((entry) => {
+                const rel = toPosix(path.relative(workspaceRoot, path.join(target, entry.name)));
+                return !isIgnoredWorkspacePath(rel);
+            });
+            const limited = visibleEntries.slice(0, MAX_LIST_ENTRIES);
+            const rows = await Promise.all(limited.map(async (entry) => {
+                const child = path.join(target, entry.name);
+                const childInfo = await stat(child).catch(() => undefined);
+                const type = entry.isDirectory()
+                    ? "dir"
+                    : entry.isFile()
+                        ? "file"
+                        : "other";
+                return {
+                    name: entry.name,
+                    type,
+                    size: type === "file" && childInfo ? childInfo.size : undefined,
+                };
+            }));
+            return JSON.stringify({
+                path: toPosix(path.relative(workspaceRoot, target) || "."),
+                truncated: entries.length > MAX_LIST_ENTRIES,
+                entries: rows,
+            }, null, 2);
+        },
+    });
+    const readToolDef = tool({
+        name: "read_workspace_file",
+        description: "Read a UTF-8 text file from the workspace. Returns up to ~256 KiB. Use list_workspace first to discover paths.",
+        parameters: z.object({
+            path: z.string().describe("Path to the file, relative to the workspace root."),
+        }),
+        async execute({ path: relPath }) {
+            const result = await readWorkspaceTextFile(workspaceRoot, relPath);
+            return JSON.stringify(result, null, 2);
+        },
+    });
+    const tools = [listTool, readToolDef];
+    if (allowWrites) {
+        const writeToolDef = tool({
+            name: "write_workspace_file",
+            description: "Write a UTF-8 text file inside the workspace. Creates parent directories as needed. Overwrites existing files. Max 1 MiB.",
+            parameters: z.object({
+                path: z
+                    .string()
+                    .describe("Destination path, relative to the workspace root."),
+                content: z.string().describe("UTF-8 text contents to write."),
+            }),
+            async execute({ path: relPath, content }) {
+                const target = resolveInside(workspaceRoot, relPath);
+                const byteLength = Buffer.byteLength(content, "utf8");
+                if (byteLength > MAX_WRITE_BYTES) {
+                    throw new Error(`Refusing to write ${byteLength} bytes; limit is ${MAX_WRITE_BYTES}.`);
+                }
+                await mkdir(path.dirname(target), { recursive: true });
+                await writeFile(target, content, "utf8");
+                return JSON.stringify({
+                    path: toPosix(path.relative(workspaceRoot, target)),
+                    bytesWritten: byteLength,
+                });
+            },
+        });
+        tools.push(writeToolDef);
+    }
+    return tools;
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "ai-discovery-manager-cli",
+  "version": "0.1.0",
+  "description": "Codex-style research manager CLI using OpenAI Agents SDK specialist agents.",
+  "type": "module",
+  "bin": {
+    "ai-discovery": "dist/cli.js"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "package.json"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/cli.ts",
+    "start": "node dist/cli.js",
+    "dry-run": "tsx src/cli.ts run --dry-run --topic \"Example thesis topic\""
+  },
+  "dependencies": {
+    "@openai/agents": "^0.11.5",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.8.0"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}