@lazarusrolando/crayoncli 0.1.0 → 0.2.0

package/.env.example

@@ -1,3 +1,5 @@
-OPENAI_API_KEY=
-OPENAI_BASE_URL=https://api.openai.com/v1
-CRAYON_MODEL=gpt-5.6
+CRAYON_MODEL=google/gemma-4-E2B-it
+CRAYON_HOST=127.0.0.1
+CRAYON_PORT=8765
+CRAYON_PYTHON=python
+CRAYON_MAX_NEW_TOKENS=1024

package/.npm-global/crayon

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/node_modules/Crayon-cli-local-gemma/dist/index.js" "$@"
+else 
+  exec node  "$basedir/node_modules/Crayon-cli-local-gemma/dist/index.js" "$@"
+fi

package/.npm-global/crayon.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\node_modules\Crayon-cli-local-gemma\dist\index.js" %*

package/.npm-global/crayon.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/node_modules/Crayon-cli-local-gemma/dist/index.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/node_modules/Crayon-cli-local-gemma/dist/index.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/node_modules/Crayon-cli-local-gemma/dist/index.js" $args
+  } else {
+    & "node$exe"  "$basedir/node_modules/Crayon-cli-local-gemma/dist/index.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

package/README.md

@@ -1,21 +1,38 @@
-# CRAYON — Open-source Crayon-style CLI
+# CRAYON v0.2.0 — Local Gemma CLI
 
-Node.js/TypeScript coding agent for local projects.
+Open-source Crayon-style CLI using Node.js/TypeScript for the agent interface and Google's Gemma model from Hugging Face for local inference.
 
-## Setup
+## Requirements
+- Node.js 20+
+- Python 3.11+
+- Sufficient RAM/VRAM for the selected Gemma model
+- Hugging Face access accepted for Gemma if required
+
+## Install
 
 ```powershell
 npm install
+python -m pip install -r model/requirements.txt
 Copy-Item .env.example .env
-# edit .env and add OPENAI_API_KEY
 npm run build
 npm link
-crayon
 ```
 
-Direct task:
+## Run
+
 ```powershell
-crayon "inspect this project and fix the failing tests"
+crayon
+crayon "explain this project"
 ```
 
-The agent can read/write files, search source code, and run development commands. Destructive shell commands require approval.
+The first run downloads the model through Transformers into the normal Hugging Face cache. Inference runs locally; CRAYON does not use the Hugging Face inference API.
+
+## Configuration
+
+```env
+CRAYON_MODEL=google/gemma-4-E2B-it
+CRAYON_HOST=127.0.0.1
+CRAYON_PORT=8765
+CRAYON_PYTHON=python
+CRAYON_MAX_NEW_TOKENS=1024
+```

package/dist/index.js

@@ -1,15 +1,45 @@
 #!/usr/bin/env node
 import "dotenv/config";
 import { Command } from "commander";
-import { interactive } from "./cli/interactive.js";
-import { Agent } from "./agent/agent.js";
-const p = new Command();
-p.name("crayon").description("Open-source AI coding agent CLI").argument("[prompt]", "task for the coding agent").option("-v, --version", "show version").action(async (prompt) => { if (!process.env.OPENAI_API_KEY) {
-    console.error("Missing OPENAI_API_KEY. Copy .env.example to .env and add your key.");
-    process.exit(1);
-} if (prompt) {
-    await new Agent().run(prompt);
-}
-else
-    await interactive(); });
-p.parseAsync();
+import chalk from "chalk";
+import { LocalGemma } from "./providers/local-gemma.js";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+const program = new Command();
+program
+    .name("crayon")
+    .description("CRAYON — local Crayon-style coding agent")
+    .argument("[task]");
+program.action(async (task) => {
+    const gemma = new LocalGemma();
+    process.on("SIGINT", () => {
+        gemma.stop();
+        process.exit(130);
+    });
+    console.log(chalk.cyan("\n╭──────────────────────────────────────────────╮"));
+    console.log(chalk.cyan("│              CRAYON LOCAL CODER                 │"));
+    console.log(chalk.cyan("│        Google Gemma · Local Inference        │"));
+    console.log(chalk.cyan("╰──────────────────────────────────────────────╯\n"));
+    if (!task) {
+        const rl = createInterface({ input, output });
+        try {
+            while (true) {
+                const q = (await rl.question(chalk.green("> "))).trim();
+                if (!q || q === "exit" || q === "quit")
+                    break;
+                console.log(chalk.dim("Thinking...\n"));
+                console.log(await gemma.generate(q));
+                console.log();
+            }
+        }
+        finally {
+            rl.close();
+            gemma.stop();
+        }
+    }
+    else {
+        console.log(await gemma.generate(task));
+        gemma.stop();
+    }
+});
+await program.parseAsync();

package/dist/providers/local-gemma.js

@@ -0,0 +1,109 @@
+import { spawn } from "node:child_process";
+import { setTimeout as delay } from "node:timers/promises";
+export class LocalGemma {
+    process;
+    python;
+    host;
+    port;
+    model;
+    constructor(options = {}) {
+        this.python = options.python ?? process.env.CRAYON_PYTHON ?? "python";
+        this.host = options.host ?? process.env.CRAYON_HOST ?? "127.0.0.1";
+        this.port = options.port ?? Number(process.env.CRAYON_PORT ?? 8765);
+        this.model =
+            options.model ??
+                process.env.CRAYON_MODEL ??
+                "google/gemma-4-E2B-it";
+    }
+    url(path) {
+        return `http://${this.host}:${this.port}${path}`;
+    }
+    async start() {
+        // Check whether a server is already running.
+        try {
+            const response = await fetch(this.url("/health"));
+            if (response.ok) {
+                return;
+            }
+        }
+        catch {
+            // Server isn't running; start it below.
+        }
+        console.log(`[CRAYON] Starting local Gemma server...`);
+        console.log(`[CRAYON] Model: ${this.model}`);
+        this.process = spawn(this.python, ["model/server.py"], {
+            stdio: ["ignore", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                CRAYON_MODEL: this.model,
+                CRAYON_HOST: this.host,
+                CRAYON_PORT: String(this.port),
+            },
+        });
+        // stdout is available because we configured it as "pipe".
+        this.process.stdout?.on("data", (data) => {
+            process.stdout.write(`\x1b[90m[Gemma] ${data.toString()}\x1b[0m`);
+        });
+        // stderr is available because we configured it as "pipe".
+        this.process.stderr?.on("data", (data) => {
+            process.stderr.write(`\x1b[90m[Gemma] ${data.toString()}\x1b[0m`);
+        });
+        this.process.on("error", (error) => {
+            console.error("[CRAYON] Failed to start Gemma:", error);
+        });
+        this.process.on("exit", (code, signal) => {
+            if (code !== 0 && code !== null) {
+                console.error(`[CRAYON] Gemma server exited with code ${code}`);
+            }
+            if (signal) {
+                console.error(`[CRAYON] Gemma server stopped by signal ${signal}`);
+            }
+        });
+        // Wait for FastAPI to become available.
+        for (let attempt = 0; attempt < 180; attempt++) {
+            try {
+                const response = await fetch(this.url("/health"));
+                if (response.ok) {
+                    console.log("[CRAYON] Gemma server is ready.");
+                    return;
+                }
+            }
+            catch {
+                // Still starting.
+            }
+            await delay(1000);
+        }
+        this.stop();
+        throw new Error("Gemma server did not become ready within 180 seconds.");
+    }
+    async generate(prompt, maxNewTokens = Number(process.env.CRAYON_MAX_NEW_TOKENS ?? 1024)) {
+        await this.start();
+        const response = await fetch(this.url("/generate"), {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({
+                prompt,
+                max_new_tokens: maxNewTokens,
+                temperature: 0.2,
+                top_p: 0.9,
+            }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Gemma server returned HTTP ${response.status}: ${errorText}`);
+        }
+        const result = (await response.json());
+        return result.text;
+    }
+    stop() {
+        if (!this.process) {
+            return;
+        }
+        if (!this.process.killed) {
+            this.process.kill();
+        }
+        this.process = undefined;
+    }
+}

package/model/requirements.txt

@@ -0,0 +1,6 @@
+torch>=2.6
+transformers>=4.57
+accelerate>=1.10
+safetensors>=0.5
+fastapi>=0.115
+uvicorn[standard]>=0.34

package/model/server.py

@@ -0,0 +1,159 @@
+import os
+import torch
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+MODEL_ID = os.getenv("CRAYON_MODEL", "google/gemma-4-E2B-it")
+HOST = os.getenv("CRAYON_HOST", "127.0.0.1")
+PORT = int(os.getenv("CRAYON_PORT", "8765"))
+
+print("=" * 60)
+print("[CRAYON] Local Gemma Server")
+print("=" * 60)
+print(f"[CRAYON] Model: {MODEL_ID}")
+print(f"[CRAYON] PyTorch: {torch.__version__}")
+print(f"[CRAYON] CUDA available: {torch.cuda.is_available()}")
+
+if torch.cuda.is_available():
+    print(f"[CRAYON] GPU: {torch.cuda.get_device_name(0)}")
+    print(f"[CRAYON] CUDA: {torch.version.cuda}")
+
+print("[CRAYON] Loading tokenizer...")
+
+tokenizer = AutoTokenizer.from_pretrained(
+    MODEL_ID
+)
+
+print("[CRAYON] Tokenizer loaded.")
+print("[CRAYON] Loading model...")
+
+model = AutoModelForCausalLM.from_pretrained(
+    MODEL_ID,
+    device_map="auto",
+    torch_dtype="auto",
+)
+
+model.eval()
+
+print("[CRAYON] Model loaded successfully.")
+
+app = FastAPI(
+    title="CRAYON Local Gemma Server",
+    version="0.2.1",
+)
+
+
+class GenerateRequest(BaseModel):
+    prompt: str
+    max_new_tokens: int = 1024
+    temperature: float = 0.2
+    top_p: float = 0.9
+
+
+@app.get("/health")
+def health():
+    return {
+        "ok": True,
+        "model": MODEL_ID,
+        "cuda": torch.cuda.is_available(),
+        "device": str(model.device),
+    }
+
+
+@app.post("/generate")
+def generate(req: GenerateRequest):
+
+    try:
+        print(f"[CRAYON] Request: {req.prompt[:100]}")
+
+        messages = [
+            {
+                "role": "user",
+                "content": req.prompt,
+            }
+        ]
+
+        # Create the model input using Gemma's chat template.
+        inputs = tokenizer.apply_chat_template(
+            messages,
+            add_generation_prompt=True,
+            tokenize=True,
+            return_tensors="pt",
+            return_dict=True,
+        )
+
+        # BatchEncoding -> tensors
+        input_ids = inputs["input_ids"]
+        attention_mask = inputs.get("attention_mask")
+
+        # Move tensors to the model's device.
+        input_ids = input_ids.to(model.device)
+
+        if attention_mask is not None:
+            attention_mask = attention_mask.to(model.device)
+
+        print(
+            f"[CRAYON] Input tokens: {input_ids.shape[-1]}"
+        )
+
+        generation_kwargs = {
+            "input_ids": input_ids,
+            "max_new_tokens": req.max_new_tokens,
+            "do_sample": req.temperature > 0,
+            "temperature": max(req.temperature, 1e-5),
+            "top_p": req.top_p,
+            "pad_token_id": tokenizer.eos_token_id,
+        }
+
+        if attention_mask is not None:
+            generation_kwargs["attention_mask"] = attention_mask
+
+        print("[CRAYON] Generating...")
+
+        with torch.inference_mode():
+
+            output = model.generate(
+                **generation_kwargs
+            )
+
+        # Remove the original prompt tokens.
+        generated_tokens = output[
+            0,
+            input_ids.shape[-1]:
+        ]
+
+        text = tokenizer.decode(
+            generated_tokens,
+            skip_special_tokens=True,
+        )
+
+        print(
+            f"[CRAYON] Generated {len(generated_tokens)} tokens."
+        )
+
+        return {
+            "text": text,
+            "model": MODEL_ID,
+        }
+
+    except Exception as exc:
+
+        print("[CRAYON] Generation error:")
+        print(repr(exc))
+
+        raise HTTPException(
+            status_code=500,
+            detail=str(exc),
+        )
+
+
+if __name__ == "__main__":
+
+    import uvicorn
+
+    uvicorn.run(
+        app,
+        host=HOST,
+        port=PORT,
+    )

package/package.json

@@ -1,29 +1,21 @@
 {
     "name": "@lazarusrolando/crayoncli",
-    "version": "0.1.0",
+    "version": "0.2.0",
     "type": "module",
     "bin": {
-        "crayon": "./dist/index.js"
+        "crayon": "dist/index.js"
     },
     "scripts": {
-        "dev": "tsx src/index.ts",
         "build": "tsc",
         "start": "node dist/index.js"
     },
     "dependencies": {
         "chalk": "^5.4.1",
-        "commander": "^14.0.0",
-        "dotenv": "^17.2.2",
-        "fast-glob": "^3.3.3",
-        "inquirer": "^12.9.4",
-        "openai": "^6.0.0",
-        "ora": "^8.2.0",
-        "pino": "^9.9.0",
-        "uuid": "^11.1.0"
+        "commander": "^14.0.1",
+        "dotenv": "^17.2.1"
     },
     "devDependencies": {
-        "@types/node": "^24.5.2",
-        "tsx": "^4.19.2",
+        "@types/node": "^24.0.0",
         "typescript": "^5.9.2"
     }
 }

package/src/index.ts

@@ -1,3 +1,52 @@
 #!/usr/bin/env node
-import "dotenv/config"; import {Command} from "commander"; import {interactive} from "./cli/interactive.js"; import {Agent} from "./agent/agent.js";
-const p=new Command();p.name("crayon").description("Open-source AI coding agent CLI").argument("[prompt]","task for the coding agent").option("-v, --version","show version").action(async(prompt:string|undefined)=>{if(!process.env.OPENAI_API_KEY){console.error("Missing OPENAI_API_KEY. Copy .env.example to .env and add your key.");process.exit(1);}if(prompt){await new Agent().run(prompt);}else await interactive();});p.parseAsync();
+import "dotenv/config";
+import { Command } from "commander";
+import chalk from "chalk";
+import { LocalGemma } from "./providers/local-gemma.js";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+
+const program = new Command();
+
+program
+  .name("crayon")
+  .description("CRAYON — local Crayon-style coding agent")
+  .argument("[task]");
+
+program.action(async (task?: string) => {
+  const gemma = new LocalGemma();
+
+  process.on("SIGINT", () => {
+    gemma.stop();
+    process.exit(130);
+  });
+
+  console.log(chalk.cyan("\n╭──────────────────────────────────────────────╮"));
+  console.log(chalk.cyan("│              CRAYON LOCAL CODER                 │"));
+  console.log(chalk.cyan("│        Google Gemma · Local Inference        │"));
+  console.log(chalk.cyan("╰──────────────────────────────────────────────╯\n"));
+
+  if (!task) {
+    const rl = createInterface({input, output});
+
+    try {
+      while (true) {
+        const q = (await rl.question(chalk.green("> "))).trim();
+
+        if (!q || q === "exit" || q === "quit") break;
+
+        console.log(chalk.dim("Thinking...\n"));
+        console.log(await gemma.generate(q));
+        console.log();
+      }
+    } finally {
+      rl.close();
+      gemma.stop();
+    }
+  } else {
+    console.log(await gemma.generate(task));
+    gemma.stop();
+  }
+});
+
+await program.parseAsync();

package/src/providers/local-gemma.ts

@@ -0,0 +1,165 @@
+import { spawn, type ChildProcess } from "node:child_process";
+import { setTimeout as delay } from "node:timers/promises";
+
+export interface GemmaOptions {
+  python?: string;
+  host?: string;
+  port?: number;
+  model?: string;
+}
+
+export class LocalGemma {
+  private process?: ChildProcess;
+
+  private readonly python: string;
+  private readonly host: string;
+  private readonly port: number;
+  private readonly model: string;
+
+  constructor(options: GemmaOptions = {}) {
+    this.python = options.python ?? process.env.CRAYON_PYTHON ?? "python";
+    this.host = options.host ?? process.env.CRAYON_HOST ?? "127.0.0.1";
+    this.port = options.port ?? Number(process.env.CRAYON_PORT ?? 8765);
+    this.model =
+      options.model ??
+      process.env.CRAYON_MODEL ??
+      "google/gemma-4-E2B-it";
+  }
+
+  private url(path: string): string {
+    return `http://${this.host}:${this.port}${path}`;
+  }
+
+  async start(): Promise<void> {
+    // Check whether a server is already running.
+    try {
+      const response = await fetch(this.url("/health"));
+
+      if (response.ok) {
+        return;
+      }
+    } catch {
+      // Server isn't running; start it below.
+    }
+
+    console.log(`[CRAYON] Starting local Gemma server...`);
+    console.log(`[CRAYON] Model: ${this.model}`);
+
+    this.process = spawn(
+      this.python,
+      ["model/server.py"],
+      {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: {
+          ...process.env,
+          CRAYON_MODEL: this.model,
+          CRAYON_HOST: this.host,
+          CRAYON_PORT: String(this.port),
+        },
+      },
+    );
+
+    // stdout is available because we configured it as "pipe".
+    this.process.stdout?.on("data", (data: Buffer) => {
+      process.stdout.write(
+        `\x1b[90m[Gemma] ${data.toString()}\x1b[0m`,
+      );
+    });
+
+    // stderr is available because we configured it as "pipe".
+    this.process.stderr?.on("data", (data: Buffer) => {
+      process.stderr.write(
+        `\x1b[90m[Gemma] ${data.toString()}\x1b[0m`,
+      );
+    });
+
+    this.process.on("error", (error) => {
+      console.error("[CRAYON] Failed to start Gemma:", error);
+    });
+
+    this.process.on("exit", (code, signal) => {
+      if (code !== 0 && code !== null) {
+        console.error(
+          `[CRAYON] Gemma server exited with code ${code}`,
+        );
+      }
+
+      if (signal) {
+        console.error(
+          `[CRAYON] Gemma server stopped by signal ${signal}`,
+        );
+      }
+    });
+
+    // Wait for FastAPI to become available.
+    for (let attempt = 0; attempt < 180; attempt++) {
+      try {
+        const response = await fetch(this.url("/health"));
+
+        if (response.ok) {
+          console.log("[CRAYON] Gemma server is ready.");
+          return;
+        }
+      } catch {
+        // Still starting.
+      }
+
+      await delay(1000);
+    }
+
+    this.stop();
+
+    throw new Error(
+      "Gemma server did not become ready within 180 seconds.",
+    );
+  }
+
+  async generate(
+    prompt: string,
+    maxNewTokens = Number(
+      process.env.CRAYON_MAX_NEW_TOKENS ?? 1024,
+    ),
+  ): Promise<string> {
+    await this.start();
+
+    const response = await fetch(this.url("/generate"), {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        prompt,
+        max_new_tokens: maxNewTokens,
+        temperature: 0.2,
+        top_p: 0.9,
+      }),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+
+      throw new Error(
+        `Gemma server returned HTTP ${response.status}: ${errorText}`,
+      );
+    }
+
+    const result = (await response.json()) as {
+      text: string;
+      model?: string;
+    };
+
+    return result.text;
+  }
+
+  stop(): void {
+    if (!this.process) {
+      return;
+    }
+
+    if (!this.process.killed) {
+      this.process.kill();
+    }
+
+    this.process = undefined;
+  }
+}

package/tsconfig.json

@@ -1 +1,15 @@
-{"compilerOptions":{"target":"ES2022","module":"NodeNext","moduleResolution":"NodeNext","strict":true,"esModuleInterop":true,"skipLibCheck":true,"outDir":"dist","rootDir":"src"},"include":["src/**/*.ts"]}
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": [
+    "src"
+  ]
+}

package/dist/agent/agent.js

@@ -1,27 +0,0 @@
-import { OpenAIProvider } from "../providers/openai.js";
-import { definitions, execute } from "../tools/registry.js";
-const SYSTEM = `You are CRAYON, an autonomous coding agent. Work inside the current project. Inspect before editing. Prefer small, safe changes. Explain what you are doing. Use tools to read/search/edit/run tests. Never claim a change was made unless the tool succeeded. Do not access files outside the project root.`;
-export class Agent {
-    provider = new OpenAIProvider();
-    messages = [{ role: "system", content: SYSTEM }];
-    async run(input) { this.messages.push({ role: "user", content: input }); for (let i = 0; i < 30; i++) {
-        const r = await this.provider.chat(this.messages, definitions);
-        if (r.content)
-            console.log(`\n${r.content}`);
-        if (!r.toolCalls.length)
-            return;
-        if (r.content)
-            this.messages.push({ role: "assistant", content: r.content });
-        for (const c of r.toolCalls) {
-            let result = "";
-            try {
-                result = await execute(c.name, JSON.parse(c.arguments));
-            }
-            catch (e) {
-                result = `ERROR: ${e instanceof Error ? e.message : String(e)}`;
-            }
-            this.messages.push({ role: "tool", tool_call_id: c.id, content: String(result) });
-            console.log(`\n● ${c.name}`);
-        }
-    } throw new Error("Agent reached maximum tool iterations."); }
-}

package/dist/cli/interactive.js

@@ -1,16 +0,0 @@
-import readline from "node:readline/promises";
-import { stdin as input, stdout as output } from "node:process";
-import { Agent } from "../agent/agent.js";
-export async function interactive() { console.log("\n╭──────────────────────────────────────────────╮\n│              CRAYON CODING AGENT                │\n│        Open-source Crayon-style CLI     │\n╰──────────────────────────────────────────────╯\n"); const rl = readline.createInterface({ input, output }); const agent = new Agent(); while (true) {
-    const q = (await rl.question("\n> ")).trim();
-    if (!q)
-        continue;
-    if (["exit", "quit"].includes(q.toLowerCase()))
-        break;
-    try {
-        await agent.run(q);
-    }
-    catch (e) {
-        console.error(`\n✖ ${e instanceof Error ? e.message : e}`);
-    }
-} rl.close(); }

package/dist/providers/openai.js

@@ -1,11 +0,0 @@
-import OpenAI from "openai";
-export class OpenAIProvider {
-    client;
-    model;
-    constructor() { this.client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY, baseURL: process.env.OPENAI_BASE_URL }); this.model = process.env.CRAYON_MODEL || "gpt-5.6"; }
-    async chat(messages, tools) {
-        const r = await this.client.chat.completions.create({ model: this.model, messages: messages, tools: tools, tool_choice: "auto" });
-        const m = r.choices[0]?.message;
-        return { content: m?.content ?? null, toolCalls: (m?.tool_calls ?? []).map((x) => ({ id: x.id, name: x.function.name, arguments: x.function.arguments })) };
-    }
-}

package/dist/providers/provider.js

@@ -1 +0,0 @@
-export {};

package/dist/tools/filesystem.js

@@ -1,29 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-const root = process.cwd();
-function safe(p) { const r = path.resolve(root, p); if (r !== root && !r.startsWith(root + path.sep))
-    throw new Error("Path escapes project root"); return r; }
-export const fsTools = [
-    { name: "read_file", description: "Read a UTF-8 text file in the project.", parameters: { type: "object", properties: { path: { type: "string" } }, required: ["path"] } },
-    { name: "write_file", description: "Write or replace a UTF-8 text file in the project.", parameters: { type: "object", properties: { path: { type: "string" }, content: { type: "string" } }, required: ["path", "content"] } },
-    { name: "list_files", description: "List project files recursively, excluding common dependency/build folders.", parameters: { type: "object", properties: { path: { type: "string" } }, required: [] } },
-];
-export async function runFs(name, args) { if (name === "read_file")
-    return await fs.readFile(safe(args.path), "utf8"); if (name === "write_file") {
-    await fs.mkdir(path.dirname(safe(args.path)), { recursive: true });
-    await fs.writeFile(safe(args.path), args.content, "utf8");
-    return `Wrote ${args.path}`;
-} if (name === "list_files") {
-    const out = [];
-    async function walk(d) { for (const e of await fs.readdir(d, { withFileTypes: true })) {
-        if (["node_modules", ".git", "dist", "build", ".next"].includes(e.name))
-            continue;
-        const p = path.join(d, e.name);
-        if (e.isDirectory())
-            await walk(p);
-        else
-            out.push(path.relative(root, p));
-    } }
-    await walk(safe(args.path || "."));
-    return out.slice(0, 500).join("\n");
-} throw new Error("Unknown filesystem tool"); }

package/dist/tools/registry.js

@@ -1,8 +0,0 @@
-import { fsTools, runFs } from "./filesystem.js";
-import { searchTool, searchCode } from "./search.js";
-import { terminalTool, runCommand } from "./terminal.js";
-export const definitions = [...fsTools.map(x => ({ type: "function", function: x })), { type: "function", function: searchTool }, { type: "function", function: terminalTool }];
-export async function execute(name, args) { if (["read_file", "write_file", "list_files"].includes(name))
-    return runFs(name, args); if (name === "search_code")
-    return searchCode(args.query); if (name === "run_command")
-    return runCommand(args.command); throw new Error(`Unknown tool: ${name}`); }

package/dist/tools/search.js

@@ -1,18 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-export const searchTool = { name: "search_code", description: "Search text across project source files.", parameters: { type: "object", properties: { query: { type: "string" } }, required: ["query"] } };
-export async function searchCode(query) { const root = process.cwd(), hits = []; async function walk(d) { for (const e of await fs.readdir(d, { withFileTypes: true })) {
-    if (["node_modules", ".git", "dist", "build", ".next"].includes(e.name))
-        continue;
-    const p = path.join(d, e.name);
-    if (e.isDirectory())
-        await walk(p);
-    else {
-        try {
-            const s = await fs.readFile(p, "utf8");
-            if (s.includes(query))
-                hits.push(path.relative(root, p));
-        }
-        catch { }
-    }
-} } await walk(root); return hits.slice(0, 100).join("\n") || "No matches."; }

package/dist/tools/terminal.js

@@ -1,13 +0,0 @@
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-import readline from "node:readline/promises";
-const ex = promisify(exec);
-export const terminalTool = { name: "run_command", description: "Run a shell command in the project. Use only for safe development commands.", parameters: { type: "object", properties: { command: { type: "string" } }, required: ["command"] } };
-const dangerous = /\b(del|erase|rmdir|rm|format|shutdown|reboot|diskpart|git\s+reset\s+--hard)\b/i;
-export async function runCommand(command) { if (dangerous.test(command)) {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    const a = await rl.question(`Approve potentially destructive command? ${command} [y/N] `);
-    rl.close();
-    if (a.toLowerCase() !== "y")
-        return "Command denied by user.";
-} const r = await ex(command, { cwd: process.cwd(), timeout: 120000, maxBuffer: 5 * 1024 * 1024, shell: process.platform === "win32" ? "powershell.exe" : true }); return (r.stdout + r.stderr).trim(); }

package/src/agent/agent.ts

@@ -1,3 +0,0 @@
-import type {Message} from "../providers/provider.js"; import {OpenAIProvider} from "../providers/openai.js"; import {definitions,execute} from "../tools/registry.js";
-const SYSTEM=`You are CRAYON, an autonomous coding agent. Work inside the current project. Inspect before editing. Prefer small, safe changes. Explain what you are doing. Use tools to read/search/edit/run tests. Never claim a change was made unless the tool succeeded. Do not access files outside the project root.`;
-export class Agent { private provider=new OpenAIProvider(); private messages:Message[]=[{role:"system",content:SYSTEM}]; async run(input:string){this.messages.push({role:"user",content:input}); for(let i=0;i<30;i++){const r=await this.provider.chat(this.messages,definitions); if(r.content) console.log(`\n${r.content}`); if(!r.toolCalls.length) return; if(r.content)this.messages.push({role:"assistant",content:r.content}); for(const c of r.toolCalls){let result="";try{result=await execute(c.name,JSON.parse(c.arguments));}catch(e){result=`ERROR: ${e instanceof Error?e.message:String(e)}`;} this.messages.push({role:"tool",tool_call_id:c.id,content:String(result)}); console.log(`\n● ${c.name}`);}} throw new Error("Agent reached maximum tool iterations.");}}

package/src/cli/interactive.ts

@@ -1,2 +0,0 @@
-import readline from "node:readline/promises"; import {stdin as input,stdout as output} from "node:process"; import {Agent} from "../agent/agent.js";
-export async function interactive(){console.log("\n╭──────────────────────────────────────────────╮\n│              CRAYON CODING AGENT                │\n│        Open-source Crayon-style CLI     │\n╰──────────────────────────────────────────────╯\n"); const rl=readline.createInterface({input,output}); const agent=new Agent(); while(true){const q=(await rl.question("\n> ")).trim();if(!q)continue;if(["exit","quit"].includes(q.toLowerCase()))break;try{await agent.run(q);}catch(e){console.error(`\n✖ ${e instanceof Error?e.message:e}`);}}rl.close();}

package/src/providers/openai.ts

@@ -1,10 +0,0 @@
-import OpenAI from "openai";
-import type { ModelProvider, Message, ToolDef, ChatResult } from "./provider.js";
-export class OpenAIProvider implements ModelProvider {
-  private client: OpenAI; private model: string;
-  constructor() { this.client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY, baseURL: process.env.OPENAI_BASE_URL }); this.model = process.env.CRAYON_MODEL || "gpt-5.6"; }
-  async chat(messages: Message[], tools: ToolDef[]): Promise<ChatResult> {
-    const r = await this.client.chat.completions.create({ model: this.model, messages: messages as any, tools: tools as any, tool_choice: "auto" });
-    const m = r.choices[0]?.message; return { content: m?.content ?? null, toolCalls: (m?.tool_calls ?? []).map((x: any) => ({ id:x.id, name:x.function.name, arguments:x.function.arguments })) };
-  }
-}

package/src/providers/provider.ts

@@ -1,4 +0,0 @@
-export type Message = { role: "system" | "user" | "assistant" | "tool"; content: string; tool_call_id?: string };
-export type ToolDef = { type: "function"; function: { name: string; description: string; parameters: Record<string, unknown> } };
-export type ChatResult = { content: string | null; toolCalls: { id: string; name: string; arguments: string }[] };
-export interface ModelProvider { chat(messages: Message[], tools: ToolDef[]): Promise<ChatResult>; }

package/src/tools/filesystem.ts

@@ -1,9 +0,0 @@
-import fs from "node:fs/promises"; import path from "node:path";
-const root = process.cwd();
-function safe(p:string){ const r=path.resolve(root,p); if(r!==root && !r.startsWith(root+path.sep)) throw new Error("Path escapes project root"); return r; }
-export const fsTools = [
-{name:"read_file",description:"Read a UTF-8 text file in the project.",parameters:{type:"object",properties:{path:{type:"string"}},required:["path"]}},
-{name:"write_file",description:"Write or replace a UTF-8 text file in the project.",parameters:{type:"object",properties:{path:{type:"string"},content:{type:"string"}},required:["path","content"]}},
-{name:"list_files",description:"List project files recursively, excluding common dependency/build folders.",parameters:{type:"object",properties:{path:{type:"string"}},required:[]}},
-];
-export async function runFs(name:string,args:any){ if(name==="read_file") return await fs.readFile(safe(args.path),"utf8"); if(name==="write_file"){await fs.mkdir(path.dirname(safe(args.path)),{recursive:true});await fs.writeFile(safe(args.path),args.content,"utf8");return `Wrote ${args.path}`;} if(name==="list_files"){const out:string[]=[]; async function walk(d:string){for(const e of await fs.readdir(d,{withFileTypes:true})){if(["node_modules",".git","dist","build",".next"].includes(e.name))continue;const p=path.join(d,e.name); if(e.isDirectory()) await walk(p); else out.push(path.relative(root,p));}} await walk(safe(args.path||".")); return out.slice(0,500).join("\n");} throw new Error("Unknown filesystem tool"); }

package/src/tools/registry.ts

@@ -1,3 +0,0 @@
-import {fsTools,runFs} from "./filesystem.js"; import {searchTool,searchCode} from "./search.js"; import {terminalTool,runCommand} from "./terminal.js"; import type {ToolDef} from "../providers/provider.js";
-export const definitions:ToolDef[]=[...fsTools.map(x=>({type:"function" as const,function:x})),{type:"function",function:searchTool},{type:"function",function:terminalTool}];
-export async function execute(name:string,args:any){if(["read_file","write_file","list_files"].includes(name))return runFs(name,args);if(name==="search_code")return searchCode(args.query);if(name==="run_command")return runCommand(args.command);throw new Error(`Unknown tool: ${name}`);}

package/src/tools/search.ts

@@ -1,3 +0,0 @@
-import fs from "node:fs/promises"; import path from "node:path";
-export const searchTool={name:"search_code",description:"Search text across project source files.",parameters:{type:"object",properties:{query:{type:"string"}},required:["query"]}};
-export async function searchCode(query:string){const root=process.cwd(), hits:string[]=[]; async function walk(d:string){for(const e of await fs.readdir(d,{withFileTypes:true})){if(["node_modules",".git","dist","build",".next"].includes(e.name))continue;const p=path.join(d,e.name);if(e.isDirectory()) await walk(p); else {try{const s=await fs.readFile(p,"utf8");if(s.includes(query)) hits.push(path.relative(root,p));}catch{}}}} await walk(root); return hits.slice(0,100).join("\n")||"No matches.";}

package/src/tools/terminal.ts

@@ -1,4 +0,0 @@
-import {exec} from "node:child_process"; import {promisify} from "node:util"; import readline from "node:readline/promises";
-const ex=promisify(exec); export const terminalTool={name:"run_command",description:"Run a shell command in the project. Use only for safe development commands.",parameters:{type:"object",properties:{command:{type:"string"}},required:["command"]}};
-const dangerous=/\b(del|erase|rmdir|rm|format|shutdown|reboot|diskpart|git\s+reset\s+--hard)\b/i;
-export async function runCommand(command:string){if(dangerous.test(command)){const rl=readline.createInterface({input:process.stdin,output:process.stdout});const a=await rl.question(`Approve potentially destructive command? ${command} [y/N] `);rl.close();if(a.toLowerCase()!=="y")return "Command denied by user.";} const r=await ex(command,{cwd:process.cwd(),timeout:120000,maxBuffer:5*1024*1024,shell:process.platform==="win32"?"powershell.exe":true});return (r.stdout+r.stderr).trim();}