@zhongqian97-code/ecode 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 zhongqian97-code
+
+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,79 @@
+# ecode
+
+A minimal [Claude Code](https://claude.ai/code) clone — REPL interface with streaming LLM responses and bash tool calling.
+
+## Install
+
+```bash
+npm install -g @zhongqian-code/ecode
+```
+
+## Usage
+
+```bash
+# Set your API key (OpenAI-compatible endpoint)
+export ECODE_API_KEY=sk-...
+
+# Start the REPL
+ecode
+```
+
+Type your message, press Enter. Type `exit` to quit.
+
+## Configuration
+
+Priority: **env vars > config file > defaults**
+
+### Environment variables
+
+| Variable | Default | Description |
+|---|---|---|
+| `ECODE_API_KEY` | *(required)* | API key |
+| `ECODE_BASE_URL` | `https://api.openai.com/v1` | Base URL (any OpenAI-compatible endpoint) |
+| `ECODE_MODEL` | `gpt-4o` | Model name |
+
+### Config file
+
+`~/.ecode/config.json`
+
+```json
+{
+  "apiKey": "sk-...",
+  "baseUrl": "https://api.openai.com/v1",
+  "model": "gpt-4o"
+}
+```
+
+### Using with other providers
+
+```bash
+# DeepSeek
+export ECODE_BASE_URL=https://api.deepseek.com/v1
+export ECODE_API_KEY=sk-...
+export ECODE_MODEL=deepseek-chat
+ecode
+
+# Local Ollama
+export ECODE_BASE_URL=http://localhost:11434/v1
+export ECODE_API_KEY=ollama
+export ECODE_MODEL=llama3
+ecode
+```
+
+## Bash tool calling
+
+ecode gives the LLM access to a bash tool. Commands are classified into three tiers:
+
+| Tier | Examples | Behavior |
+|---|---|---|
+| **Allow** | `ls`, `cat`, `pwd`, `echo` | Auto-execute, no prompt |
+| **Normal** | `git status`, `npm install` | Single confirmation |
+| **Danger** | `rm -rf`, `sudo`, `chmod` | Double confirmation |
+
+## Requirements
+
+- Node.js >= 18
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+
+// src/config.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var DEFAULTS = {
+  baseUrl: "https://api.openai.com/v1",
+  apiKey: "",
+  model: "gpt-4o"
+};
+function loadConfig() {
+  const configPath = join(homedir(), ".ecode", "config.json");
+  let fileConfig = {};
+  if (existsSync(configPath)) {
+    try {
+      const raw = readFileSync(configPath, "utf-8");
+      fileConfig = JSON.parse(raw);
+    } catch {
+    }
+  }
+  return {
+    baseUrl: process.env.ECODE_BASE_URL ?? fileConfig.baseUrl ?? DEFAULTS.baseUrl,
+    apiKey: process.env.ECODE_API_KEY ?? fileConfig.apiKey ?? DEFAULTS.apiKey,
+    model: process.env.ECODE_MODEL ?? fileConfig.model ?? DEFAULTS.model
+  };
+}
+
+// src/repl.ts
+import * as readline from "readline/promises";
+
+// src/safety.ts
+var ALLOWLIST = [
+  "ls",
+  "cat",
+  "pwd",
+  "echo",
+  "head",
+  "tail",
+  "wc",
+  "date",
+  "whoami",
+  "which",
+  "env",
+  "printenv"
+];
+var DANGER_LIST = [
+  "rm -rf",
+  "sudo",
+  "chmod",
+  "chown",
+  "mkfs",
+  "dd",
+  "fdisk",
+  "kill",
+  "pkill",
+  "killall",
+  "reboot",
+  "shutdown",
+  "halt",
+  "curl -X DELETE",
+  "wget --delete-after"
+];
+function matchesEntry(cmd, entry) {
+  return cmd === entry || cmd.startsWith(entry + " ");
+}
+function classifyCommand(cmd) {
+  const trimmed = cmd.trim();
+  for (const entry of DANGER_LIST) {
+    if (matchesEntry(trimmed, entry)) return "danger";
+  }
+  for (const entry of ALLOWLIST) {
+    if (matchesEntry(trimmed, entry)) return "allow";
+  }
+  return "normal";
+}
+
+// src/llm.ts
+import OpenAI from "openai";
+function createLLMClient(config2) {
+  const openai = new OpenAI({
+    baseURL: config2.baseUrl,
+    apiKey: config2.apiKey
+  });
+  return {
+    stream(messages, tools) {
+      return {
+        [Symbol.asyncIterator]: async function* () {
+          const requestParams = {
+            model: config2.model,
+            messages,
+            stream: true
+          };
+          if (tools && tools.length > 0) {
+            requestParams.tools = tools;
+          }
+          const response = await openai.chat.completions.create(requestParams);
+          const tcAccumulator = /* @__PURE__ */ new Map();
+          for await (const chunk of response) {
+            const choice = chunk.choices[0];
+            if (!choice) continue;
+            const deltaToolCalls = choice.delta.tool_calls;
+            if (deltaToolCalls) {
+              for (const tc of deltaToolCalls) {
+                if (!tcAccumulator.has(tc.index)) {
+                  tcAccumulator.set(tc.index, {
+                    id: tc.id ?? "",
+                    name: tc.function?.name ?? "",
+                    arguments: ""
+                  });
+                }
+                const existing = tcAccumulator.get(tc.index);
+                if (tc.id) existing.id = tc.id;
+                if (tc.function?.name) existing.name = tc.function.name;
+                existing.arguments += tc.function?.arguments ?? "";
+              }
+            }
+            const isLast = choice.finish_reason !== null;
+            if (isLast) {
+              yield {
+                text: choice.delta.content ?? "",
+                done: true,
+                finishReason: choice.finish_reason,
+                toolCalls: tcAccumulator.size > 0 ? Array.from(tcAccumulator.values()) : void 0
+              };
+            } else {
+              yield {
+                text: choice.delta.content ?? "",
+                done: false
+              };
+            }
+          }
+        }
+      };
+    }
+  };
+}
+
+// src/tools/bash.ts
+import { exec } from "child_process";
+var DEFAULT_TIMEOUT_MS = 3e4;
+function executeBash(cmd, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    exec(cmd, { timeout: timeoutMs }, (err, result) => {
+      const stdout = result?.stdout ?? "";
+      const stderr = result?.stderr ?? "";
+      if (err) {
+        const exitCode = err.code ?? 1;
+        resolve({ stdout, stderr, exitCode });
+      } else {
+        resolve({ stdout, stderr, exitCode: 0 });
+      }
+    });
+  });
+}
+
+// src/repl.ts
+var SKIP_MESSAGE = "Command skipped by user.";
+var BASH_TOOL = {
+  type: "function",
+  function: {
+    name: "bash",
+    description: "Execute a shell command and return its output.",
+    parameters: {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "The shell command to run." }
+      },
+      required: ["command"]
+    }
+  }
+};
+async function handleBashTool(command, deps) {
+  const { confirm, print } = deps;
+  const cls = classifyCommand(command);
+  if (cls === "normal") {
+    const ok = await confirm(`Execute command: ${command}
+Proceed? (y/n) `);
+    if (!ok) return SKIP_MESSAGE;
+  } else if (cls === "danger") {
+    print(`\u26A0\uFE0F  DANGEROUS COMMAND: ${command}`);
+    const first = await confirm("Are you sure? (y/n) ");
+    if (!first) return SKIP_MESSAGE;
+    const second = await confirm(
+      "Confirm again \u2014 this is destructive. Continue? (y/n) "
+    );
+    if (!second) return SKIP_MESSAGE;
+  }
+  const result = await deps.executeBash(command);
+  let output = "";
+  if (result.stdout) output += result.stdout;
+  if (result.stderr) output += result.stderr;
+  if (result.exitCode !== 0) output += `
+[exit code: ${result.exitCode}]`;
+  return output || "(no output)";
+}
+async function startRepl(config2) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const llm = createLLMClient(config2);
+  const messages = [];
+  const print = (text) => process.stdout.write(text);
+  const confirm = async (prompt) => {
+    const answer = await rl.question(prompt);
+    return answer.trim().toLowerCase() === "y";
+  };
+  const deps = { executeBash, confirm, print };
+  console.log('ecode \u2014 type "exit" to quit\n');
+  while (true) {
+    const input = await rl.question("you: ").catch(() => "exit");
+    const trimmed = input.trim();
+    if (trimmed === "exit" || trimmed === "quit") break;
+    if (!trimmed) continue;
+    messages.push({ role: "user", content: trimmed });
+    let continueLoop = true;
+    while (continueLoop) {
+      continueLoop = false;
+      process.stdout.write("assistant: ");
+      let assistantText = "";
+      const toolCalls = [];
+      for await (const chunk of llm.stream(messages, [BASH_TOOL])) {
+        if (chunk.text) {
+          process.stdout.write(chunk.text);
+          assistantText += chunk.text;
+        }
+        if (chunk.done && chunk.toolCalls) {
+          toolCalls.push(...chunk.toolCalls);
+        }
+      }
+      if (toolCalls.length > 0) {
+        messages.push({
+          role: "assistant",
+          content: assistantText || null,
+          tool_calls: toolCalls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: { name: tc.name, arguments: tc.arguments }
+          }))
+        });
+        for (const tc of toolCalls) {
+          if (tc.name === "bash") {
+            let args;
+            try {
+              args = JSON.parse(tc.arguments);
+            } catch {
+              args = { command: "" };
+            }
+            print(`
+[bash] ${args.command}
+`);
+            const toolResult = await handleBashTool(args.command, deps);
+            print(toolResult + "\n");
+            messages.push({
+              role: "tool",
+              tool_call_id: tc.id,
+              content: toolResult
+            });
+          }
+        }
+        continueLoop = true;
+      } else {
+        process.stdout.write("\n");
+        if (assistantText) {
+          messages.push({ role: "assistant", content: assistantText });
+        }
+      }
+    }
+  }
+  rl.close();
+  console.log("\nBye!");
+}
+
+// src/index.ts
+var config = loadConfig();
+if (!config.apiKey) {
+  console.error(
+    "Error: no API key configured.\nSet ECODE_API_KEY or add apiKey to ~/.ecode/config.json"
+  );
+  process.exit(1);
+}
+startRepl(config).catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@zhongqian97-code/ecode",
+  "version": "0.0.1",
+  "description": "A minimal Claude Code clone with REPL interface and bash tool calling",
+  "type": "module",
+  "author": "zhongqian97-code",
+  "license": "MIT",
+  "keywords": [
+    "cli",
+    "repl",
+    "llm",
+    "openai",
+    "claude",
+    "ai",
+    "tool-calling",
+    "bash"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zhongqian97-code/ecode.git"
+  },
+  "homepage": "https://github.com/zhongqian97-code/ecode#readme",
+  "bugs": {
+    "url": "https://github.com/zhongqian97-code/ecode/issues"
+  },
+  "bin": {
+    "ecode": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "openai": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^18.0.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^2.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}