@lazarusrolando/crayoncli 0.0.0-stage → 0.2.0

package/.env.example

@@ -0,0 +1,5 @@
+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,3 +1,38 @@
-# Temporary Holding Version
+# CRAYON v0.2.0 — Local Gemma CLI
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Open-source Crayon-style CLI using Node.js/TypeScript for the agent interface and Google's Gemma model from Hugging Face for local inference.
+
+## 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
+npm run build
+npm link
+```
+
+## Run
+
+```powershell
+crayon
+crayon "explain this project"
+```
+
+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

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+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) => {
+    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,6 +1,21 @@
-{
-  "name": "@lazarusrolando/crayoncli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+    "name": "@lazarusrolando/crayoncli",
+    "version": "0.2.0",
+    "type": "module",
+    "bin": {
+        "crayon": "dist/index.js"
+    },
+    "scripts": {
+        "build": "tsc",
+        "start": "node dist/index.js"
+    },
+    "dependencies": {
+        "chalk": "^5.4.1",
+        "commander": "^14.0.1",
+        "dotenv": "^17.2.1"
+    },
+    "devDependencies": {
+        "@types/node": "^24.0.0",
+        "typescript": "^5.9.2"
+    }
+}

package/src/index.ts

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+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

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