@lazarusrolando/crayoncli 0.1.0 → 0.3.0

package/.env.example

@@ -1,3 +1,6 @@
-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
+CRAYON_TEMPERATURE=0.7

package/README.md

@@ -1,21 +1,40 @@
-# CRAYON — Open-source Crayon-style CLI
+# CRAYON v0.3.0 — Local Gemma Streaming
 
-Node.js/TypeScript coding agent for local projects.
+Real local token streaming for the CRAYON CLI.
 
-## Setup
+## Flow
+
+You → Node.js CLI → local FastAPI → Transformers TextIteratorStreamer → local Gemma → tokens → CLI
+
+Hugging Face is only the model repository. Inference is local.
+
+## 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
+node dist/index.js
+```
+
+or:
+
 ```powershell
-crayon "inspect this project and fix the failing tests"
+node dist/index.js "Explain recursion in JavaScript"
 ```
 
-The agent can read/write files, search source code, and run development commands. Destructive shell commands require approval.
+## What v0.3 adds
+
+- `TextIteratorStreamer` for local token streaming
+- background generation thread
+- FastAPI `StreamingResponse`
+- Node.js `ReadableStream` consumption
+- keeps `/generate` for non-streaming compatibility
+
+Streaming changes delivery timing, not the inference provider. The model still runs locally.

package/dist/index.js

@@ -1,15 +1,54 @@
-#!/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);
+import readline from "node:readline";
+import { LocalGemma } from "./providers/local-gemma.js";
+const gemma = new LocalGemma({
+    python: process.env.CRAYON_PYTHON || "python",
+    model: process.env.CRAYON_MODEL || "google/gemma-4-E2B-it",
+    host: process.env.CRAYON_HOST || "127.0.0.1",
+    port: Number(process.env.CRAYON_PORT || 8765),
+    maxNewTokens: Number(process.env.CRAYON_MAX_NEW_TOKENS || 1024),
+    temperature: Number(process.env.CRAYON_TEMPERATURE || 0.7)
+});
+async function main() {
+    const oneShot = process.argv.slice(2).join(" ").trim();
+    await gemma.start();
+    if (oneShot) {
+        await gemma.generateStream(oneShot);
+        gemma.stop();
+        return;
+    }
+    console.log("\n==========================================");
+    console.log("       CRAYON v0.3.0 - LOCAL STREAMING");
+    console.log("==========================================");
+    console.log("Gemma inference: LOCAL");
+    console.log("Hugging Face inference API: NOT USED");
+    console.log("Streaming: ENABLED\n");
+    console.log("Type /exit to quit.\n");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: "You: " });
+    const shutdown = () => { rl.close(); gemma.stop(); process.exit(0); };
+    process.on("SIGINT", shutdown);
+    rl.prompt();
+    rl.on("line", async (line) => {
+        const prompt = line.trim();
+        if (!prompt) {
+            rl.prompt();
+            return;
+        }
+        if (prompt === "/exit") {
+            shutdown();
+            return;
+        }
+        rl.pause();
+        try {
+            await gemma.generateStream(prompt);
+        }
+        catch (error) {
+            console.error("\n[CRAYON ERROR]", error instanceof Error ? error.message : error);
+        }
+        finally {
+            rl.resume();
+            rl.prompt();
+        }
+    });
 }
-else
-    await interactive(); });
-p.parseAsync();
+main().catch(error => { console.error("[CRAYON FATAL]", error); gemma.stop(); process.exit(1); });

package/dist/providers/local-gemma.js

@@ -0,0 +1,79 @@
+import { spawn } from "node:child_process";
+export class LocalGemma {
+    process;
+    options;
+    baseUrl;
+    constructor(options) {
+        this.options = options;
+        this.baseUrl = `http://${options.host}:${options.port}`;
+    }
+    async start() {
+        if (await this.isReady())
+            return;
+        console.log("[CRAYON] Starting local Gemma server...");
+        console.log(`[CRAYON] Model: ${this.options.model}`);
+        this.process = spawn(this.options.python, ["model/server.py"], {
+            stdio: ["ignore", "pipe", "pipe"],
+            env: { ...process.env, CRAYON_MODEL: this.options.model, CRAYON_HOST: this.options.host,
+                CRAYON_PORT: String(this.options.port) }
+        });
+        this.process.stdout?.on("data", (d) => process.stdout.write(`[Gemma] ${d.toString()}`));
+        this.process.stderr?.on("data", (d) => process.stderr.write(`[Gemma] ${d.toString()}`));
+        const deadline = Date.now() + 180000;
+        while (Date.now() < deadline) {
+            if (await this.isReady()) {
+                console.log("[CRAYON] Local Gemma server is ready.");
+                return;
+            }
+            await new Promise(r => setTimeout(r, 1000));
+        }
+        throw new Error("Gemma server did not become ready within 180 seconds.");
+    }
+    async isReady() {
+        try {
+            return (await fetch(`${this.baseUrl}/health`)).ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    async generateStream(prompt) {
+        const response = await fetch(`${this.baseUrl}/generate/stream`, {
+            method: "POST", headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ prompt, max_new_tokens: this.options.maxNewTokens, temperature: this.options.temperature })
+        });
+        if (!response.ok)
+            throw new Error(`Gemma streaming error (${response.status}): ${await response.text()}`);
+        if (!response.body)
+            throw new Error("Gemma returned no streaming body.");
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        process.stdout.write("\nCRAYON: ");
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                process.stdout.write(decoder.decode(value, { stream: true }));
+            }
+            process.stdout.write(decoder.decode());
+            process.stdout.write("\n");
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    async generate(prompt) {
+        const response = await fetch(`${this.baseUrl}/generate`, {
+            method: "POST", headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ prompt, max_new_tokens: this.options.maxNewTokens, temperature: this.options.temperature })
+        });
+        if (!response.ok)
+            throw new Error(`Gemma error (${response.status}): ${await response.text()}`);
+        return (await response.json()).text;
+    }
+    stop() {
+        if (this.process && !this.process.killed)
+            this.process.kill();
+    }
+}

package/model/requirements.txt

@@ -0,0 +1,6 @@
+fastapi
+uvicorn[standard]
+transformers
+torch
+accelerate
+sentencepiece

package/model/server.py

@@ -0,0 +1,113 @@
+import os
+from threading import Thread
+import torch
+from fastapi import FastAPI
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
+
+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(f"[CRAYON MODEL] Loading: {MODEL_ID}",flush=True)
+print(f"[CRAYON MODEL] CUDA available: {torch.cuda.is_available()}",flush=True)
+tokenizer=AutoTokenizer.from_pretrained(MODEL_ID)
+model=AutoModelForCausalLM.from_pretrained(MODEL_ID,device_map="auto",torch_dtype="auto")
+model.eval()
+print("[CRAYON MODEL] Model loaded.",flush=True)
+print(f"[CRAYON MODEL] Device: {model.device}",flush=True)
+
+app=FastAPI(title="CRAYON Local Gemma Server",version="0.3.0")
+
+class GenerateRequest(BaseModel):
+    prompt:str
+    max_new_tokens:int=1024
+    temperature:float=0.7
+
+@app.get("/health")
+def health():
+    return {"status":"ok","model":MODEL_ID,"device":str(model.device),
+            "cuda":torch.cuda.is_available(),"streaming":True,"inference":"local"}
+
+def build_inputs(prompt):
+    messages=[{"role":"user","content":prompt}]
+    inputs=tokenizer.apply_chat_template(messages,tokenize=True,add_generation_prompt=True,
+                                          return_tensors="pt",return_dict=True)
+    input_ids=inputs["input_ids"].to(model.device)
+    attention_mask=inputs.get("attention_mask")
+    if attention_mask is not None:
+        attention_mask=attention_mask.to(model.device)
+    return input_ids,attention_mask
+
+@app.post("/generate/stream")
+def generate_stream(request:GenerateRequest):
+    input_ids,attention_mask=build_inputs(request.prompt)
+    streamer=TextIteratorStreamer(tokenizer,skip_prompt=True,skip_special_tokens=True)
+    kwargs={"input_ids":input_ids,"streamer":streamer,
+            "max_new_tokens":request.max_new_tokens,
+            "do_sample":request.temperature>0}
+    if attention_mask is not None: kwargs["attention_mask"]=attention_mask
+    if request.temperature>0: kwargs["temperature"]=request.temperature
+
+    worker=Thread(target=model.generate,kwargs=kwargs,daemon=True)
+    worker.start()
+
+    def token_iterator():
+        generated_text = ""
+        chunk_count = 0
+
+        try:
+            for text in streamer:
+                chunk_count += 1
+                generated_text += text
+
+                # TextIteratorStreamer emits decoded text chunks. Re-tokenize
+                # accumulated output to report the generated-token count.
+                token_count = len(
+                    tokenizer.encode(
+                        generated_text,
+                        add_special_tokens=False,
+                    )
+                )
+
+                print(
+                    f"[CRAYON TOKEN] #{token_count}: {text!r}",
+                    flush=True,
+                )
+
+                yield text
+
+            final_token_count = len(
+                tokenizer.encode(
+                    generated_text,
+                    add_special_tokens=False,
+                )
+            )
+
+            print(
+                f"[CRAYON STREAM] Generation complete | "
+                f"chunks={chunk_count} | "
+                f"generated_tokens={final_token_count}",
+                flush=True,
+            )
+        finally:
+            worker.join()
+
+    return StreamingResponse(token_iterator(),media_type="text/plain; charset=utf-8",
+                             headers={"Cache-Control":"no-cache","X-CRAYON-Streaming":"true"})
+
+@app.post("/generate")
+def generate(request:GenerateRequest):
+    input_ids,attention_mask=build_inputs(request.prompt)
+    kwargs={"input_ids":input_ids,"max_new_tokens":request.max_new_tokens,
+            "do_sample":request.temperature>0}
+    if attention_mask is not None: kwargs["attention_mask"]=attention_mask
+    if request.temperature>0: kwargs["temperature"]=request.temperature
+    output=model.generate(**kwargs)
+    new_tokens=output[0][input_ids.shape[-1]:]
+    return {"text":tokenizer.decode(new_tokens,skip_special_tokens=True)}
+
+if __name__=="__main__":
+    import uvicorn
+    uvicorn.run(app,host=HOST,port=PORT)

package/package.json

@@ -1,29 +1,18 @@
 {
     "name": "@lazarusrolando/crayoncli",
-    "version": "0.1.0",
+    "version": "0.3.0",
     "type": "module",
-    "bin": {
-        "crayon": "./dist/index.js"
-    },
     "scripts": {
-        "dev": "tsx src/index.ts",
         "build": "tsc",
-        "start": "node dist/index.js"
+        "start": "node dist/index.js",
+        "dev": "tsx src/index.ts"
     },
     "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"
+        "dotenv": "^16.4.7"
     },
     "devDependencies": {
-        "@types/node": "^24.5.2",
+        "@types/node": "^22.10.5",
         "tsx": "^4.19.2",
-        "typescript": "^5.9.2"
+        "typescript": "^5.7.2"
     }
 }

package/src/index.ts

@@ -1,3 +1,43 @@
-#!/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 readline from "node:readline";
+import { LocalGemma } from "./providers/local-gemma.js";
+
+const gemma=new LocalGemma({
+  python:process.env.CRAYON_PYTHON||"python",
+  model:process.env.CRAYON_MODEL||"google/gemma-4-E2B-it",
+  host:process.env.CRAYON_HOST||"127.0.0.1",
+  port:Number(process.env.CRAYON_PORT||8765),
+  maxNewTokens:Number(process.env.CRAYON_MAX_NEW_TOKENS||1024),
+  temperature:Number(process.env.CRAYON_TEMPERATURE||0.7)
+});
+
+async function main(){
+  const oneShot=process.argv.slice(2).join(" ").trim();
+  await gemma.start();
+
+  if(oneShot){ await gemma.generateStream(oneShot); gemma.stop(); return; }
+
+  console.log("\n==========================================");
+  console.log("       CRAYON v0.3.0 - LOCAL STREAMING");
+  console.log("==========================================");
+  console.log("Gemma inference: LOCAL");
+  console.log("Hugging Face inference API: NOT USED");
+  console.log("Streaming: ENABLED\n");
+  console.log("Type /exit to quit.\n");
+
+  const rl=readline.createInterface({input:process.stdin,output:process.stdout,prompt:"You: "});
+  const shutdown=()=>{rl.close();gemma.stop();process.exit(0);};
+  process.on("SIGINT",shutdown);
+  rl.prompt();
+
+  rl.on("line",async line=>{
+    const prompt=line.trim();
+    if(!prompt){rl.prompt();return;}
+    if(prompt==="/exit"){shutdown();return;}
+    rl.pause();
+    try{await gemma.generateStream(prompt);}
+    catch(error){console.error("\n[CRAYON ERROR]",error instanceof Error?error.message:error);}
+    finally{rl.resume();rl.prompt();}
+  });
+}
+main().catch(error=>{console.error("[CRAYON FATAL]",error);gemma.stop();process.exit(1);});

package/src/providers/local-gemma.ts

@@ -0,0 +1,78 @@
+import { spawn, ChildProcess } from "node:child_process";
+
+export interface GemmaOptions {
+  python:string; model:string; host:string; port:number;
+  maxNewTokens:number; temperature:number;
+}
+
+export class LocalGemma {
+  private process?:ChildProcess;
+  private readonly options:GemmaOptions;
+  private readonly baseUrl:string;
+
+  constructor(options:GemmaOptions){
+    this.options=options;
+    this.baseUrl=`http://${options.host}:${options.port}`;
+  }
+
+  async start():Promise<void>{
+    if(await this.isReady()) return;
+    console.log("[CRAYON] Starting local Gemma server...");
+    console.log(`[CRAYON] Model: ${this.options.model}`);
+
+    this.process=spawn(this.options.python,["model/server.py"],{
+      stdio:["ignore","pipe","pipe"],
+      env:{...process.env,CRAYON_MODEL:this.options.model,CRAYON_HOST:this.options.host,
+           CRAYON_PORT:String(this.options.port)}
+    });
+
+    this.process.stdout?.on("data",(d:Buffer)=>process.stdout.write(`[Gemma] ${d.toString()}`));
+    this.process.stderr?.on("data",(d:Buffer)=>process.stderr.write(`[Gemma] ${d.toString()}`));
+
+    const deadline=Date.now()+180000;
+    while(Date.now()<deadline){
+      if(await this.isReady()){ console.log("[CRAYON] Local Gemma server is ready."); return; }
+      await new Promise(r=>setTimeout(r,1000));
+    }
+    throw new Error("Gemma server did not become ready within 180 seconds.");
+  }
+
+  async isReady():Promise<boolean>{
+    try{return (await fetch(`${this.baseUrl}/health`)).ok;}catch{return false;}
+  }
+
+  async generateStream(prompt:string):Promise<void>{
+    const response=await fetch(`${this.baseUrl}/generate/stream`,{
+      method:"POST",headers:{"Content-Type":"application/json"},
+      body:JSON.stringify({prompt,max_new_tokens:this.options.maxNewTokens,temperature:this.options.temperature})
+    });
+    if(!response.ok) throw new Error(`Gemma streaming error (${response.status}): ${await response.text()}`);
+    if(!response.body) throw new Error("Gemma returned no streaming body.");
+
+    const reader=response.body.getReader();
+    const decoder=new TextDecoder();
+    process.stdout.write("\nCRAYON: ");
+    try{
+      while(true){
+        const {done,value}=await reader.read();
+        if(done) break;
+        process.stdout.write(decoder.decode(value,{stream:true}));
+      }
+      process.stdout.write(decoder.decode());
+      process.stdout.write("\n");
+    }finally{reader.releaseLock();}
+  }
+
+  async generate(prompt:string):Promise<string>{
+    const response=await fetch(`${this.baseUrl}/generate`,{
+      method:"POST",headers:{"Content-Type":"application/json"},
+      body:JSON.stringify({prompt,max_new_tokens:this.options.maxNewTokens,temperature:this.options.temperature})
+    });
+    if(!response.ok) throw new Error(`Gemma error (${response.status}): ${await response.text()}`);
+    return ((await response.json()) as {text:string}).text;
+  }
+
+  stop():void{
+    if(this.process && !this.process.killed) this.process.kill();
+  }
+}

package/tsconfig.json

@@ -1 +1 @@
-{"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/**/*.ts"]}

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();}