codeshark-cli 0.1.1

package/dist/tools/files.js

@@ -0,0 +1,288 @@
+import { mkdirSync, readFileSync, statSync, writeFileSync, readdirSync } from "node:fs";
+import { dirname, relative, resolve } from "node:path";
+import { resolveProjectPath } from "../project.js";
+function resolvePath(p, cwd) {
+    const s = String(p ?? "").trim();
+    if (!s)
+        return cwd;
+    return resolveProjectPath(s, cwd);
+}
+function prettyPath(p, cwd) {
+    const r = relative(cwd, p);
+    return r && !r.startsWith("..") ? r : p;
+}
+const MAX_READ_BYTES = 10 * 1024 * 1024;
+const MAX_LIST_ENTRIES = 300;
+const MAX_GLOB_MATCHES = 200;
+function looksBinary(text) {
+    return text.includes("\u0000");
+}
+export const readFileTool = {
+    name: "read_file",
+    description: "Read a text file. Use offset (1-based line number) and limit (number of lines) to read large files in windows. Output is line-numbered.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Path to the file, absolute or relative to the working directory." },
+            offset: { type: "integer", description: "1-based starting line. Default 1." },
+            limit: { type: "integer", description: "Max lines to return. Default: whole file." },
+        },
+        required: ["path"],
+    },
+    run(args, ctx) {
+        const p = resolvePath(args.path, ctx.cwd);
+        const st = statSync(p, { throwIfNoEntry: false });
+        if (!st)
+            throw new Error(`File not found: ${prettyPath(p, ctx.cwd)}`);
+        if (st.isDirectory())
+            throw new Error(`${prettyPath(p, ctx.cwd)} is a directory — use list_directory instead.`);
+        if (st.size > MAX_READ_BYTES) {
+            throw new Error(`File is ${Math.round(st.size / 1024 / 1024)} MB — too large to read whole. Use offset/limit to page through it.`);
+        }
+        const text = readFileSync(p, "utf8");
+        if (looksBinary(text))
+            throw new Error(`File appears to be binary — refusing to read as text.`);
+        const lines = text.split("\n");
+        const start = args.offset ? Math.max(1, Number(args.offset)) : 1;
+        const end = args.limit ? Math.min(lines.length, start + Number(args.limit) - 1) : lines.length;
+        const body = lines
+            .slice(start - 1, end)
+            .map((line, i) => `${String(start + i).padStart(5)} | ${line}`)
+            .join("\n");
+        const trunc = end < lines.length ? `\n... (${lines.length - end} more lines; continue with offset=${end + 1})` : "";
+        return `File: ${prettyPath(p, ctx.cwd)} (${lines.length} lines)\n${body}${trunc}`;
+    },
+};
+export const writeFileTool = {
+    name: "write_file",
+    description: "Create a new file or overwrite an existing one with the given content. Creates parent directories. Use edit_file for surgical changes to existing files.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Path to the file to write." },
+            content: { type: "string", description: "Full content of the file." },
+        },
+        required: ["path", "content"],
+    },
+    run(args, ctx) {
+        const p = resolvePath(args.path, ctx.cwd);
+        const content = String(args.content ?? "");
+        mkdirSync(dirname(p), { recursive: true });
+        writeFileSync(p, content, "utf8");
+        return `Wrote ${Buffer.byteLength(content, "utf8")} bytes to ${prettyPath(p, ctx.cwd)}.`;
+    },
+};
+export const editFileTool = {
+    name: "edit_file",
+    description: "Make a surgical change to an existing file: replace exactly one occurrence of oldString with newString. The oldString must match the file exactly (including whitespace) and appear exactly once, otherwise the edit is rejected — this prevents accidental corrupting edits.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Path to the file to edit." },
+            oldString: { type: "string", description: "The exact text to replace (must appear exactly once in the file)." },
+            newString: { type: "string", description: "The replacement text." },
+        },
+        required: ["path", "oldString", "newString"],
+    },
+    run(args, ctx) {
+        const p = resolvePath(args.path, ctx.cwd);
+        const oldString = String(args.oldString ?? "");
+        const newString = String(args.newString ?? "");
+        if (!oldString)
+            throw new Error("oldString must not be empty.");
+        const st = statSync(p, { throwIfNoEntry: false });
+        if (!st)
+            throw new Error(`File not found: ${prettyPath(p, ctx.cwd)}`);
+        const text = readFileSync(p, "utf8");
+        if (looksBinary(text))
+            throw new Error("File appears to be binary — refusing to edit as text.");
+        let count = 0;
+        let idx = -1;
+        let from = 0;
+        while (true) {
+            const hit = text.indexOf(oldString, from);
+            if (hit === -1)
+                break;
+            count++;
+            if (idx === -1)
+                idx = hit;
+            from = hit + oldString.length;
+        }
+        if (count === 0) {
+            throw new Error(`oldString not found in ${prettyPath(p, ctx.cwd)}. It must match the file exactly — check whitespace/indentation.`);
+        }
+        if (count > 1) {
+            throw new Error(`oldString matches ${count} times in ${prettyPath(p, ctx.cwd)}. Make it more specific (include surrounding lines).`);
+        }
+        const next = text.slice(0, idx) + newString + text.slice(idx + oldString.length);
+        writeFileSync(p, next, "utf8");
+        const line = (text.slice(0, idx).match(/\n/g)?.length ?? 0) + 1;
+        return `Edited ${prettyPath(p, ctx.cwd)} (line ${line}): replaced ${oldString.length} chars with ${newString.length} chars.`;
+    },
+};
+export const listDirectoryTool = {
+    name: "list_directory",
+    description: "List the files and subdirectories in a directory. Directories are suffixed with '/'.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Directory to list. Defaults to the working directory." },
+        },
+    },
+    run(args, ctx) {
+        const p = resolvePath(args.path, ctx.cwd);
+        const st = statSync(p, { throwIfNoEntry: false });
+        if (!st)
+            return `Directory not found: ${prettyPath(p, ctx.cwd)}`;
+        if (!st.isDirectory())
+            return `${prettyPath(p, ctx.cwd)} is not a directory.`;
+        const entries = readdirSync(p, { withFileTypes: true })
+            .sort((a, b) => (a.name < b.name ? -1 : 1))
+            .map((e) => (e.isDirectory() ? `${e.name}/` : e.name));
+        const shown = entries.slice(0, MAX_LIST_ENTRIES);
+        const trunc = entries.length > MAX_LIST_ENTRIES ? `\n... (${entries.length - MAX_LIST_ENTRIES} more entries)` : "";
+        return `Directory: ${prettyPath(p, ctx.cwd)} (${entries.length} entries)\n${shown.join("\n")}${trunc}`;
+    },
+};
+/** Minimal glob → RegExp conversion supporting **, *, ?, and {a,b}. */
+export function globToRegExp(glob) {
+    let re = "^";
+    let i = 0;
+    while (i < glob.length) {
+        const ch = glob[i];
+        if (ch === "*") {
+            if (glob[i + 1] === "*") {
+                // "**/" may match zero directories; bare "**" matches anything.
+                if (glob[i + 2] === "/") {
+                    re += "(?:.*/)?";
+                    i += 3;
+                }
+                else {
+                    re += ".*";
+                    i += 2;
+                }
+            }
+            else {
+                re += "[^/]*";
+                i += 1;
+            }
+        }
+        else if (ch === "?") {
+            re += "[^/]";
+            i += 1;
+        }
+        else if (ch === "{") {
+            const end = glob.indexOf("}", i);
+            if (end === -1) {
+                re += "\\{";
+                i += 1;
+            }
+            else {
+                const alts = glob
+                    .slice(i + 1, end)
+                    .split(",")
+                    .map((a) => a.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+                    .join("|");
+                re += `(?:${alts})`;
+                i = end + 1;
+            }
+        }
+        else if (ch === "[") {
+            const end = glob.indexOf("]", i);
+            if (end === -1) {
+                re += "\\[";
+                i += 1;
+            }
+            else {
+                re += glob.slice(i, end + 1);
+                i = end + 1;
+            }
+        }
+        else {
+            re += ch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            i += 1;
+        }
+    }
+    return new RegExp(re + "$");
+}
+const SKIP_DIRS = new Set(["node_modules", ".git", "dist", ".next", "target", "vendor", "__pycache__"]);
+function walkFiles(dir, out, depth) {
+    if (depth > 12)
+        return;
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        if (out.length >= MAX_GLOB_MATCHES)
+            return;
+        if (e.name.startsWith("."))
+            continue; // skip hidden
+        if (e.isDirectory()) {
+            if (SKIP_DIRS.has(e.name))
+                continue;
+            walkFiles(resolve(dir, e.name), out, depth + 1);
+        }
+        else if (e.isFile()) {
+            out.push(resolve(dir, e.name));
+        }
+    }
+}
+export const globTool = {
+    name: "glob",
+    description: "Find files matching a glob pattern, e.g. \"src/**/*.ts\" or \"*.json\". Skips node_modules, .git, and hidden files by default.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            pattern: { type: "string", description: "Glob pattern. Supports **, *, ?, and {a,b}." },
+            cwd: { type: "string", description: "Directory to search from. Defaults to the working directory." },
+        },
+        required: ["pattern"],
+    },
+    run(args, ctx) {
+        const pattern = String(args.pattern ?? "");
+        if (!pattern)
+            return "pattern is required.";
+        const cwd = args.cwd ? resolvePath(args.cwd, ctx.cwd) : ctx.cwd;
+        const staticPrefix = pattern.slice(0, pattern.indexOf("*"));
+        const prefix = staticPrefix.split(/[\\/]/).slice(0, -1).join("/") || ".";
+        const searchRoot = resolveProjectPath(prefix, cwd);
+        if (!statSync(searchRoot, { throwIfNoEntry: false })?.isDirectory()) {
+            return `No matches for ${pattern}`;
+        }
+        const all = [];
+        walkFiles(searchRoot, all, 0);
+        const rx = globToRegExp(pattern.replace(/\\/g, "/"));
+        const matches = all
+            .map((f) => relative(cwd, f).replace(/\\/g, "/"))
+            .filter((f) => rx.test(f))
+            .slice(0, MAX_GLOB_MATCHES);
+        if (!matches.length)
+            return `No matches for ${pattern}`;
+        return `${matches.length} match${matches.length === 1 ? "" : "es"} for ${pattern}:\n${matches.join("\n")}`;
+    },
+};
+export const finishTool = {
+    name: "finish",
+    description: "Signal that the task is complete. Call this with a short summary of what was done instead of answering in chat text.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            summary: { type: "string", description: "One or two sentence summary of what was accomplished." },
+        },
+    },
+    run(args) {
+        const summary = String(args.summary ?? "").trim();
+        return summary || "Task complete.";
+    },
+};
+export const fileTools = [
+    readFileTool,
+    writeFileTool,
+    editFileTool,
+    listDirectoryTool,
+    globTool,
+];

package/dist/tools/index.js

@@ -0,0 +1,16 @@
+import { ToolRegistry } from "./registry.js";
+import { fileTools, finishTool } from "./files.js";
+import { codeSearchTool } from "./search.js";
+import { runCommandTool } from "./shell.js";
+/** Build the standard CodeShark toolset (working dir comes per-call via ToolContext). */
+export function createRegistry() {
+    const reg = new ToolRegistry();
+    for (const t of fileTools)
+        reg.add(t);
+    reg.add(codeSearchTool);
+    reg.add(runCommandTool);
+    reg.add(finishTool);
+    return reg;
+}
+export { ToolRegistry } from "./registry.js";
+export { isDangerousCommand } from "./shell.js";

package/dist/tools/registry.js

@@ -0,0 +1,34 @@
+export class ToolRegistry {
+    tools = new Map();
+    add(tool) {
+        this.tools.set(tool.name, tool);
+        return this;
+    }
+    names() {
+        return [...this.tools.keys()];
+    }
+    schemas() {
+        return [...this.tools.values()].map((t) => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.inputSchema,
+        }));
+    }
+    async execute(name, args, ctx) {
+        const tool = this.tools.get(name);
+        if (!tool) {
+            return {
+                content: `Unknown tool: ${name}. Available tools: ${this.names().join(", ")}`,
+                isError: true,
+            };
+        }
+        try {
+            const content = await tool.run(args, ctx);
+            return { content: String(content), isError: false };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return { content: `Tool ${name} failed: ${msg}`, isError: true };
+        }
+    }
+}

package/dist/tools/search.js

@@ -0,0 +1,154 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { relative } from "node:path";
+import { resolveProjectPath } from "../project.js";
+import { spawn } from "node:child_process";
+const MAX_RESULTS = 200;
+const SKIP_DIRS = new Set(["node_modules", ".git", "dist", ".next", "target", "vendor", "__pycache__"]);
+function exec(cmd, args, timeoutMs) {
+    return new Promise((resolvePromise) => {
+        const child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (d) => (stdout += d));
+        child.stderr.on("data", (d) => (stderr += d));
+        const timer = setTimeout(() => child.kill("SIGKILL"), timeoutMs);
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            resolvePromise({ code, stdout, stderr });
+        });
+        child.on("error", () => {
+            clearTimeout(timer);
+            resolvePromise({ code: null, stdout, stderr: "spawn failed" });
+        });
+    });
+}
+function parseFlags(flags) {
+    return {
+        caseInsensitive: /-i/.test(flags),
+        filesOnly: /-l/.test(flags),
+        word: /-w/.test(flags),
+        context: (/-C\s*(\d+)/.exec(flags)?.[1] ? Number(/-C\s*(\d+)/.exec(flags)[1]) : 0) || 0,
+    };
+}
+/** Dependency-free fallback when ripgrep isn't installed. */
+function jsSearch(root, pattern, flags) {
+    const { caseInsensitive, filesOnly, context } = parseFlags(flags);
+    let rx;
+    try {
+        rx = new RegExp(pattern, caseInsensitive ? "i" : "");
+    }
+    catch {
+        return `Invalid regex: ${pattern}`;
+    }
+    const results = [];
+    const walk = (dir, depth) => {
+        if (depth > 12 || results.length >= MAX_RESULTS)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (results.length >= MAX_RESULTS)
+                return;
+            if (e.name.startsWith("."))
+                continue;
+            const full = resolveProjectPath(e.name, dir);
+            if (e.isDirectory()) {
+                if (SKIP_DIRS.has(e.name))
+                    continue;
+                walk(full, depth + 1);
+                continue;
+            }
+            if (!e.isFile())
+                continue;
+            let text;
+            try {
+                text = readFileSync(full, "utf8");
+            }
+            catch {
+                continue;
+            }
+            if (text.includes("\u0000"))
+                continue; // binary
+            const rel = relative(root, full).replace(/\\/g, "/");
+            const lines = text.split("\n");
+            if (filesOnly) {
+                if (lines.some((l) => rx.test(l)))
+                    results.push(rel);
+                continue;
+            }
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                if (!rx.test(line))
+                    continue;
+                results.push(`${rel}:${i + 1}:${line.length > 240 ? line.slice(0, 240) + "…" : line}`);
+                if (context > 0) {
+                    for (let c = 1; c <= context; c++) {
+                        const idx = i + c;
+                        if (idx < lines.length && results.length < MAX_RESULTS) {
+                            results.push(`${rel}:${idx + 1}:${lines[idx]}`);
+                        }
+                    }
+                }
+            }
+        }
+    };
+    walk(root, 0);
+    return results.length ? results.join("\n") : `No matches for ${pattern} in ${relative(process.cwd(), root) || root}`;
+}
+export const codeSearchTool = {
+    name: "code_search",
+    description: "Search file contents with a regular expression (ripgrep if installed, a built-in fallback otherwise). Returns up to 200 matches with line numbers. Flags: -i case-insensitive, -l files only, -w whole word, -C n context lines.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            pattern: { type: "string", description: "Regular expression to search for." },
+            cwd: { type: "string", description: "Directory to search. Defaults to the working directory." },
+            flags: { type: "string", description: "Optional flags: -i, -l, -w, -C n." },
+        },
+        required: ["pattern"],
+    },
+    async run(args, ctx) {
+        const pattern = String(args.pattern ?? "");
+        if (!pattern)
+            return "pattern is required.";
+        const cwd = args.cwd ? resolveProjectPath(String(args.cwd), ctx.cwd) : ctx.cwd;
+        const flags = String(args.flags ?? "");
+        if (!statSync(cwd, { throwIfNoEntry: false })?.isDirectory())
+            return `Not a directory: ${cwd}`;
+        // Prefer ripgrep; fall back to the JS implementation.
+        const rg = await exec("rg", ["--version"], 3000);
+        if (rg.code === 0) {
+            const rgArgs = [
+                "--line-number",
+                "--no-heading",
+                "--color",
+                "never",
+                "-m",
+                String(MAX_RESULTS),
+                "--max-columns",
+                "240",
+                ...(/-i/.test(flags) ? ["-i"] : []),
+                ...(/-l/.test(flags) ? ["-l"] : []),
+                ...(/-w/.test(flags) ? ["-w"] : []),
+                ...(/-C\s*(\d+)/.test(flags) ? ["-C", /-C\s*(\d+)/.exec(flags)[1]] : []),
+                pattern,
+                cwd,
+            ];
+            const res = await exec("rg", rgArgs, 15000);
+            if (res.code === 0 || res.code === 1) {
+                return res.stdout.trim() || `No matches for ${pattern}`;
+            }
+            if (res.code === 2) {
+                return `rg error: ${res.stderr.trim().slice(0, 300) || "invalid regex or path"}`;
+            }
+        }
+        return jsSearch(cwd, pattern, flags);
+    },
+};
+/** Exported for tests. */
+export { jsSearch, parseFlags };

package/dist/tools/shell.js

@@ -0,0 +1,105 @@
+import { spawn, spawnSync } from "node:child_process";
+import { resolveProjectPath } from "../project.js";
+const MAX_OUTPUT_CHARS = 30_000;
+const DEFAULT_TIMEOUT_MS = 30_000;
+/**
+ * Commands that a coding agent should never run on the user's machine without
+ * explicit human approval. CodeShark blocks these by default; set
+ * CODESHARK_ALLOW_DANGEROUS=1 to disable the blocklist.
+ */
+const DANGEROUS_PATTERNS = [
+    { re: /\brm\s+-(?:[a-z]*r[a-z]*f|f[a-z]*r)\b/i, why: "recursive force delete (rm -rf)" },
+    { re: /\bgit\s+push\b/, why: "git push (changes the remote)" },
+    { re: /\bgit\s+(?:reset|rebase|clean)\b/, why: "destructive git operation" },
+    { re: /\bsudo\b/, why: "sudo / privilege escalation" },
+    { re: /\bdd\s+if=/, why: "dd can overwrite disks" },
+    { re: /\bmkfs(?:\.\w+)?\b/, why: "filesystem formatting" },
+    { re: /\b>:?\s*\/dev\/sd/, why: "raw disk writes" },
+    { re: /\b(?:curl|wget)\b.*\|\s*(?:ba)?sh\b/i, why: "downloading and executing a script from the internet" },
+    { re: /\bchmod\s+-R\b/, why: "recursive permission change" },
+    { re: /\bkill\s+-9\b/, why: "force-killing processes" },
+];
+export function isDangerousCommand(command) {
+    const c = command.trim();
+    for (const { re, why } of DANGEROUS_PATTERNS) {
+        if (re.test(c))
+            return why;
+    }
+    return null;
+}
+let shellCommand = null;
+function pickShell() {
+    if (shellCommand)
+        return shellCommand;
+    if (process.platform === "win32") {
+        // Prefer Git Bash; fall back to cmd.exe.
+        const probe = spawnSync("bash", ["--version"], { stdio: "ignore" });
+        if (probe.status === 0) {
+            shellCommand = { cmd: "bash", args: (c) => ["-lc", c] };
+        }
+        else {
+            shellCommand = { cmd: "cmd.exe", args: (c) => ["/d", "/s", "/c", c] };
+        }
+    }
+    else {
+        shellCommand = { cmd: "bash", args: (c) => ["-lc", c] };
+    }
+    return shellCommand;
+}
+function truncate(s) {
+    if (s.length <= MAX_OUTPUT_CHARS)
+        return s;
+    return `${s.slice(0, MAX_OUTPUT_CHARS)}\n… (truncated ${s.length - MAX_OUTPUT_CHARS} chars)`;
+}
+export const runCommandTool = {
+    name: "run_command",
+    description: "Run a shell command (bash on macOS/Linux/Git-Bash, cmd.exe as fallback on Windows) and return its output. The command runs in the working directory with a default 30s timeout (override with timeoutMs). Output is capped at ~30k chars. Destructive commands (rm -rf, git push, sudo, …) are blocked by default.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            command: { type: "string", description: "The shell command to run." },
+            cwd: { type: "string", description: "Working directory for the command. Defaults to the working directory." },
+            timeoutMs: { type: "integer", description: "Timeout in milliseconds. Default 30000." },
+        },
+        required: ["command"],
+    },
+    async run(args, ctx) {
+        const command = String(args.command ?? "").trim();
+        if (!command)
+            return "No command provided.";
+        const cwd = args.cwd ? resolveProjectPath(String(args.cwd), ctx.cwd) : ctx.cwd;
+        const timeoutMs = args.timeoutMs ? Math.max(1000, Number(args.timeoutMs)) : DEFAULT_TIMEOUT_MS;
+        const danger = isDangerousCommand(command);
+        if (danger && !process.env.CODESHARK_ALLOW_DANGEROUS) {
+            throw new Error(`Blocked: "${command}" matches the danger pattern "${danger}". CodeShark refuses destructive commands by default (set CODESHARK_ALLOW_DANGEROUS=1 to override).`);
+        }
+        const shell = pickShell();
+        return new Promise((resolvePromise) => {
+            const child = spawn(shell.cmd, shell.args(command), { cwd, stdio: ["ignore", "pipe", "pipe"] });
+            let stdout = "";
+            let stderr = "";
+            let timedOut = false;
+            child.stdout.on("data", (d) => (stdout += d));
+            child.stderr.on("data", (d) => (stderr += d));
+            const timer = setTimeout(() => {
+                timedOut = true;
+                child.kill("SIGKILL");
+            }, timeoutMs);
+            child.on("close", (code) => {
+                clearTimeout(timer);
+                const parts = [`$ ${command}`, `exit code: ${timedOut ? `timed out after ${timeoutMs}ms` : code}`];
+                if (stdout.trim())
+                    parts.push(`stdout:\n${truncate(stdout).trimEnd()}`);
+                if (stderr.trim())
+                    parts.push(`stderr:\n${truncate(stderr).trimEnd()}`);
+                resolvePromise(parts.join("\n"));
+            });
+            child.on("error", (e) => {
+                clearTimeout(timer);
+                resolvePromise(`Failed to spawn shell: ${e.message}`);
+            });
+        });
+    },
+};
+/** Exported for tests. */
+export { DANGEROUS_PATTERNS };

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "codeshark-cli",
+  "version": "0.1.1",
+  "description": "An open-source terminal coding agent with a pixel-shark mascot. Five frontier models, zero setup, no API keys required.",
+  "type": "module",
+  "bin": {
+    "codeshark": "./dist/index.js"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "README.md",
+    "TERMS.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/codeshark/codeshark.git"
+  },
+  "homepage": "https://github.com/codeshark/codeshark",
+  "bugs": {
+    "url": "https://github.com/codeshark/codeshark/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.17"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "npm run build && node --test \"test/**/*.test.ts\"",
+    "start": "node dist/index.js",
+    "banner": "node dist/index.js banner",
+    "worker:build": "tsc -p worker/tsconfig.json",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "cli",
+    "ai",
+    "agent",
+    "coding-agent",
+    "unorouter",
+    "terminal",
+    "llm"
+  ],
+  "license": "MIT",
+  "author": "CodeShark contributors",
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "typescript": "^5.7.2"
+  }
+}