sharkcode 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 syy-shark
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,104 @@
+# Shark Code
+
+> Local First, open-source AI coding agent.
+> A small CLI inspired by Claude Code / OpenCode, with DeepSeek as the default provider.
+
+## Install
+
+### Global install from npm
+
+```bash
+npm install -g sharkcode
+```
+
+Then run:
+
+```bash
+sharkcode "explain this codebase"
+sharkcode "fix the null pointer bug in auth.ts"
+sharkcode "add error handling to the API routes"
+```
+
+### Run from source
+
+```bash
+git clone https://github.com/syy-shark/sharkcode.git
+cd sharkcode
+bun install
+bun run start "explain this codebase"
+```
+
+## Configure API Key
+
+Shark Code reads `DEEPSEEK_API_KEY` from either an environment variable or `~/.sharkcode/config.toml`.
+
+### Option 1: Environment variable
+
+macOS / Linux:
+
+```bash
+export DEEPSEEK_API_KEY=sk-xxxxxx
+```
+
+Windows PowerShell:
+
+```powershell
+$env:DEEPSEEK_API_KEY="sk-xxxxxx"
+```
+
+### Option 2: Config file
+
+`~/.sharkcode/config.toml`
+
+```toml
+[api]
+key = "sk-xxxxxx"
+model = "deepseek-chat"
+base_url = "https://api.deepseek.com/v1"
+```
+
+## Upgrade
+
+When you publish a new version to npm, users can upgrade with:
+
+```bash
+npm update -g sharkcode
+```
+
+## Publish
+
+```bash
+npm login
+npm publish
+```
+
+Every code update is published as a new npm version. Typical flow:
+
+1. Update code.
+2. Bump `version` in `package.json`.
+3. Run `npm publish`.
+
+## How It Works
+
+```text
+User input -> Prompt + Tools -> LLM -> Tool execution -> Result -> Repeat
+```
+
+Built-in tools:
+
+| Tool | Description |
+|------|-------------|
+| `read_file` | Read a file |
+| `write_file` | Create or overwrite a file |
+| `edit_file` | Replace an exact string in a file |
+| `bash` | Execute a shell command with approval |
+
+## Tech Stack
+
+- Bun + TypeScript
+- Vercel AI SDK
+- DeepSeek API
+
+## License
+
+MIT

package/dist/cli.mjs

@@ -0,0 +1,351 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import chalk3 from "chalk";
+
+// src/config.ts
+import { parse } from "smol-toml";
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var CONFIG_DIR = join(homedir(), ".sharkcode");
+var CONFIG_FILE = join(CONFIG_DIR, "config.toml");
+var DEFAULT_CONFIG = `# Shark Code Configuration
+# https://github.com/syy-ex/sharkcode
+
+[api]
+# Get your API key from https://platform.deepseek.com
+# Or set DEEPSEEK_API_KEY environment variable
+key = ""
+model = "deepseek-chat"
+base_url = "https://api.deepseek.com/v1"
+`;
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  if (!existsSync(CONFIG_FILE)) {
+    writeFileSync(CONFIG_FILE, DEFAULT_CONFIG, "utf-8");
+  }
+}
+function loadConfig() {
+  ensureConfigDir();
+  let toml = {};
+  try {
+    const raw = readFileSync(CONFIG_FILE, "utf-8");
+    toml = parse(raw);
+  } catch {
+  }
+  const api = toml.api ?? {};
+  const apiKey = process.env.DEEPSEEK_API_KEY || api.key || "";
+  const model = api.model || "deepseek-chat";
+  const baseURL = api.base_url || "https://api.deepseek.com/v1";
+  if (!apiKey) {
+    console.error("\u274C No API key found.");
+    console.error(`   Set DEEPSEEK_API_KEY env var or edit ${CONFIG_FILE}`);
+    process.exit(1);
+  }
+  return { apiKey, model, baseURL };
+}
+
+// src/agent.ts
+import { stepCountIs, streamText } from "ai";
+import chalk2 from "chalk";
+
+// src/tools/read-file.ts
+import { tool } from "ai";
+import { z } from "zod";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { resolve } from "path";
+var readFileTool = tool({
+  description: "Read the contents of a file at the given path. Returns the file content as a string.",
+  inputSchema: z.object({
+    path: z.string().describe("File path to read (relative to current working directory)")
+  }),
+  execute: async ({ path: filePath }) => {
+    const fullPath = resolve(process.cwd(), filePath);
+    if (!existsSync2(fullPath)) {
+      return `Error: File not found: ${filePath}`;
+    }
+    try {
+      return readFileSync2(fullPath, "utf-8");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return `Error reading file: ${msg}`;
+    }
+  }
+});
+
+// src/tools/write-file.ts
+import { tool as tool2 } from "ai";
+import { z as z2 } from "zod";
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { resolve as resolve2, dirname } from "path";
+var writeFileTool = tool2({
+  description: "Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Creates parent directories as needed.",
+  inputSchema: z2.object({
+    path: z2.string().describe("File path to write to (relative to current working directory)"),
+    content: z2.string().describe("The content to write to the file")
+  }),
+  execute: async ({ path: filePath, content }) => {
+    const fullPath = resolve2(process.cwd(), filePath);
+    try {
+      mkdirSync2(dirname(fullPath), { recursive: true });
+      writeFileSync2(fullPath, content, "utf-8");
+      return `Successfully wrote to ${filePath}`;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return `Error writing file: ${msg}`;
+    }
+  }
+});
+
+// src/tools/edit-file.ts
+import { tool as tool3 } from "ai";
+import { z as z3 } from "zod";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3 } from "fs";
+import { resolve as resolve3 } from "path";
+var editFileTool = tool3({
+  description: "Edit a file by replacing an exact string match with new content. The old_str must match exactly one occurrence in the file.",
+  inputSchema: z3.object({
+    path: z3.string().describe("File path to edit (relative to current working directory)"),
+    old_str: z3.string().describe("The exact string to find and replace"),
+    new_str: z3.string().describe("The replacement string")
+  }),
+  execute: async ({ path: filePath, old_str, new_str }) => {
+    const fullPath = resolve3(process.cwd(), filePath);
+    if (!existsSync3(fullPath)) {
+      return `Error: File not found: ${filePath}`;
+    }
+    try {
+      const content = readFileSync3(fullPath, "utf-8");
+      const count = content.split(old_str).length - 1;
+      if (count === 0) {
+        return `Error: old_str not found in ${filePath}`;
+      }
+      if (count > 1) {
+        return `Error: old_str found ${count} times in ${filePath}, expected exactly 1. Include more context to make it unique.`;
+      }
+      const newContent = content.replace(old_str, new_str);
+      writeFileSync3(fullPath, newContent, "utf-8");
+      return `Successfully edited ${filePath}`;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return `Error editing file: ${msg}`;
+    }
+  }
+});
+
+// src/tools/bash.ts
+import { tool as tool4 } from "ai";
+import { z as z4 } from "zod";
+import { exec } from "child_process";
+
+// src/permission.ts
+import * as readline from "readline";
+import chalk from "chalk";
+async function askPermission(command) {
+  process.stderr.write(
+    chalk.yellow(`
+\u26A0\uFE0F  Will execute: `) + chalk.white(command) + "\n"
+  );
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr
+  });
+  return new Promise((resolve4) => {
+    rl.question(chalk.yellow("   Allow? [y/N] "), (answer) => {
+      rl.close();
+      const yes = answer.trim().toLowerCase();
+      resolve4(yes === "y" || yes === "yes");
+    });
+  });
+}
+
+// src/tools/bash.ts
+var bashTool = tool4({
+  description: "Execute a shell command. The command will be shown to the user for approval before execution. Use this for running tests, installing packages, checking git status, etc.",
+  inputSchema: z4.object({
+    command: z4.string().describe("The shell command to execute")
+  }),
+  execute: async ({ command }) => {
+    const allowed = await askPermission(command);
+    if (!allowed) {
+      return "Command execution denied by user.";
+    }
+    return new Promise((resolve4) => {
+      exec(
+        command,
+        {
+          cwd: process.cwd(),
+          timeout: 12e4,
+          maxBuffer: 1024 * 1024 * 5
+        },
+        (error, stdout, stderr) => {
+          let result = "";
+          if (stdout) result += stdout;
+          if (stderr) result += (result ? "\n" : "") + `[stderr]: ${stderr}`;
+          if (error && error.code !== null) {
+            result += (result ? "\n" : "") + `[exit code]: ${error.code}`;
+          }
+          resolve4(result || "(no output)");
+        }
+      );
+    });
+  }
+});
+
+// src/tools/index.ts
+var tools = {
+  read_file: readFileTool,
+  write_file: writeFileTool,
+  edit_file: editFileTool,
+  bash: bashTool
+};
+
+// src/provider.ts
+import { createOpenAI } from "@ai-sdk/openai";
+function createProvider(config) {
+  const provider = createOpenAI({
+    baseURL: config.baseURL,
+    apiKey: config.apiKey,
+    name: "deepseek"
+  });
+  return provider.chat(config.model);
+}
+
+// src/agent.ts
+function buildSystemPrompt() {
+  return `You are Shark Code, an AI coding assistant. You help users with coding tasks by reading, writing, and editing files, and running shell commands.
+
+Current working directory: ${process.cwd()}
+Environment: Windows with PowerShell. Use PowerShell-compatible commands, not bash syntax.
+
+Available tools:
+- read_file: Read the contents of a file
+- write_file: Create or overwrite a file (creates parent dirs)
+- edit_file: Find and replace an exact string in a file
+- bash: Execute a shell command (requires user approval)
+
+Guidelines:
+- Always read a file before editing it
+- Explain what you plan to do before making changes
+- Use edit_file for targeted changes, write_file for creating new files
+- When using shell commands, prefer PowerShell built-ins or commands that work on Windows
+- Keep changes minimal and focused on the user's request
+- When done, summarize what you changed`;
+}
+async function runAgent(prompt, config) {
+  const model = createProvider(config);
+  const result = streamText({
+    model,
+    system: buildSystemPrompt(),
+    prompt,
+    tools,
+    stopWhen: stepCountIs(30)
+  });
+  let currentStep = 0;
+  for await (const event of result.fullStream) {
+    switch (event.type) {
+      case "text-delta":
+        process.stdout.write(event.text);
+        break;
+      case "tool-input-available":
+        process.stdout.write(
+          chalk2.cyan(`
+\u{1F527} ${event.toolName}`) + chalk2.gray(`(${formatArgs(event.input)})
+`)
+        );
+        break;
+      case "tool-output-available":
+        process.stdout.write(
+          chalk2.green(`\u2705 tool`) + chalk2.gray(` \u2192 ${truncate(String(event.output), 120)}
+
+`)
+        );
+        break;
+      case "tool-output-error":
+        process.stderr.write(chalk2.red(`
+\u274C Tool error: ${event.errorText}
+`));
+        break;
+      case "finish-step":
+        currentStep++;
+        break;
+      case "error":
+        process.stderr.write(chalk2.red(`
+\u274C Error: ${event.errorText}
+`));
+        break;
+    }
+  }
+  process.stdout.write("\n");
+  const usage = await result.totalUsage;
+  if (usage) {
+    process.stderr.write(
+      chalk2.gray(
+        `
+\u{1F4CA} Tokens: ${usage.inputTokens} in / ${usage.outputTokens} out | Steps: ${currentStep}
+`
+      )
+    );
+  }
+}
+function formatArgs(args) {
+  if (typeof args !== "object" || args === null) return String(args);
+  const obj = args;
+  return Object.entries(obj).map(([k, v]) => {
+    const val = typeof v === "string" ? truncate(v, 60) : String(v);
+    return `${k}: ${val}`;
+  }).join(", ");
+}
+function truncate(str, max) {
+  const oneLine = str.replace(/\n/g, "\\n");
+  return oneLine.length > max ? oneLine.slice(0, max) + "\u2026" : oneLine;
+}
+
+// src/cli.ts
+var BANNER = chalk3.bold.cyan(`
+  \u{1F988} Shark Code v0.1
+  AI Coding Agent \u2014 Local First, Open Source
+`);
+var HELP = `${BANNER}
+${chalk3.white("Usage:")}
+  ${chalk3.green("sharkcode")} ${chalk3.yellow('"your prompt here"')}
+
+${chalk3.white("Examples:")}
+  sharkcode "explain this codebase"
+  sharkcode "fix the null pointer bug in auth.ts"
+  sharkcode "add error handling to the API routes"
+
+${chalk3.white("Config:")}
+  Set ${chalk3.yellow("DEEPSEEK_API_KEY")} env var, or edit ${chalk3.gray("~/.sharkcode/config.toml")}
+  Get your key at ${chalk3.underline("https://platform.deepseek.com")}
+`;
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    console.log(HELP);
+    return;
+  }
+  if (args[0] === "--version" || args[0] === "-v") {
+    console.log("sharkcode v0.1.0");
+    return;
+  }
+  const prompt = args.join(" ");
+  const config = loadConfig();
+  process.stdout.write(
+    chalk3.cyan("\u{1F988} Shark Code") + chalk3.gray(` | model: ${config.model}
+
+`)
+  );
+  await runAgent(prompt, config);
+}
+main().catch((err) => {
+  console.error(chalk3.red(`
+\u274C Fatal: ${err.message}`));
+  if (err.message?.includes("401") || err.message?.includes("Unauthorized")) {
+    console.error(chalk3.yellow("   Check your API key in ~/.sharkcode/config.toml"));
+  }
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "sharkcode",
+  "version": "0.1.0",
+  "description": "Local First, open-source AI Coding Agent",
+  "type": "module",
+  "bin": {
+    "sharkcode": "dist/cli.mjs"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "bun src/cli.ts",
+    "dev": "bun --watch src/cli.ts",
+    "build": "tsup",
+    "test": "bun test",
+    "prepublishOnly": "npm run build && bun test"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/node": "^24.6.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@ai-sdk/openai": "^3.0.48",
+    "ai": "^6.0.141",
+    "chalk": "^5.6.2",
+    "smol-toml": "^1.6.1",
+    "zod": "^4.3.6"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/syy-shark/sharkcode.git"
+  },
+  "homepage": "https://github.com/syy-shark/sharkcode",
+  "bugs": {
+    "url": "https://github.com/syy-shark/sharkcode/issues"
+  }
+}