@thejeetsingh/kalcode 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jeet Singh
+
+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,142 @@
+# kalcode
+
+CLI coding agent powered by NVIDIA NIM.
+
+## Install
+
+Global install:
+
+```bash
+npm i -g @thejeetsingh/kalcode
+```
+
+Run without global install:
+
+```bash
+npx @thejeetsingh/kalcode --version
+```
+
+## Usage
+
+```bash
+kalcode "your prompt here"
+```
+
+## Publish to npm
+
+1. Login:
+
+```bash
+npm login
+```
+
+2. Check what will be published:
+
+```bash
+npm pack --dry-run
+```
+
+3. Publish:
+
+```bash
+npm publish --access public
+```
+
+4. Verify:
+
+```bash
+npm view @thejeetsingh/kalcode version
+```
+
+## Deployment and Secrets
+
+- Do not hardcode API keys in source files.
+- Set `NVIDIA_NIM_KEY` in your shell or deployment environment.
+- Use `kalcode --set-key` to store the key in `~/.kalcode/config.json` for local development.
+- TLS verification is on by default. Do not disable it in production.
+- `KALCODE_INSECURE_TLS=1` is available only as a local debugging escape hatch.
+
+## Secure Proxy Mode (share access without sharing your NVIDIA key)
+
+Run the backend proxy with your NVIDIA key on a server you control:
+
+```bash
+export NVIDIA_NIM_KEY="your-real-provider-key"
+export KALCODE_PROXY_TOKEN="choose-a-long-random-token"
+export PORT=8787
+bun run proxy
+```
+
+Client users run `kalcode` with proxy settings (no NVIDIA key needed on client):
+
+```bash
+export KALCODE_PROXY_URL="https://your-proxy-domain"
+export KALCODE_PROXY_TOKEN="same-token-as-server"
+kalcode
+```
+
+Optional server hardening vars:
+
+- `KALCODE_PROXY_RATE_LIMIT_PER_MIN` - per-client request cap (default `120`)
+- `HOST` - bind host (default `0.0.0.0`)
+- `PORT` - bind port (default `8787`)
+
+Health check endpoint:
+
+```bash
+curl https://your-proxy-domain/health
+```
+
+## Vercel Deployment (serverless)
+
+This repo now includes Vercel serverless endpoints:
+
+- `POST /v1/chat/completions` (rewritten to `/api/v1/chat/completions`)
+- `GET /health` (rewritten to `/api/health`)
+
+### 1) Deploy
+
+- Import the `kalcode` folder as a Vercel project.
+- Framework preset: **Other**.
+- Build command: leave default/empty.
+
+### 2) Set Vercel environment variables
+
+- `NVIDIA_NIM_KEY` = your provider key (server-only)
+- `KALCODE_PROXY_TOKEN` = long random token for client auth
+
+### 3) Configure clients
+
+```bash
+export KALCODE_PROXY_URL="https://<your-vercel-project>.vercel.app"
+export KALCODE_PROXY_TOKEN="<same-token-as-vercel-env>"
+kalcode
+```
+
+### 4) Verify
+
+```bash
+curl https://<your-vercel-project>.vercel.app/health
+```
+
+## Options
+
+- `-h, --help` - Show help
+- `-v, --version` - Show version
+- `-m, --model <id>` - Use a specific model
+- `--set-key` - Set NVIDIA NIM API key
+- `--compact` - Compact output
+- `--auto-accept` - Skip permission prompts
+- `--ask` - Read-only mode
+
+## REPL Commands
+
+- `/help` - Show help
+- `/model` - Show or switch model
+- `/clear` - Clear conversation
+- `/retry` - Retry last message
+- `/compact` - Toggle compact output
+- `/ask` - Toggle read-only mode
+- `/skills` - List skills
+- `/` - Show slash commands
+- `/exit` - Quit

package/api/health.ts

@@ -0,0 +1,10 @@
+export const runtime = "edge";
+
+export default async function handler(): Promise<Response> {
+  return new Response(JSON.stringify({ ok: true }), {
+    status: 200,
+    headers: {
+      "Content-Type": "application/json",
+    },
+  });
+}

package/api/v1/chat/completions.ts

@@ -0,0 +1,59 @@
+const API_URL = "https://integrate.api.nvidia.com/v1/chat/completions";
+
+export const runtime = "edge";
+
+function json(status: number, payload: Record<string, unknown>): Response {
+  return new Response(JSON.stringify(payload), {
+    status,
+    headers: {
+      "Content-Type": "application/json",
+    },
+  });
+}
+
+function getBearerToken(req: Request): string {
+  const auth = req.headers.get("authorization") || "";
+  const m = auth.match(/^Bearer\s+(.+)$/i);
+  return m?.[1]?.trim() || "";
+}
+
+export default async function handler(req: Request): Promise<Response> {
+  if (req.method !== "POST") {
+    return json(405, { error: { message: "Method not allowed." } });
+  }
+
+  const serverNimKey = process.env.NVIDIA_NIM_KEY || "";
+  const requiredProxyToken = process.env.KALCODE_PROXY_TOKEN || "";
+
+  if (!serverNimKey) {
+    return json(500, { error: { message: "Server missing NVIDIA_NIM_KEY." } });
+  }
+
+  if (requiredProxyToken) {
+    const incoming = getBearerToken(req);
+    if (!incoming || incoming !== requiredProxyToken) {
+      return json(401, { error: { message: "Unauthorized." } });
+    }
+  }
+
+  const body = await req.text();
+  const upstream = await fetch(API_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${serverNimKey}`,
+    },
+    body,
+  });
+
+  const headers = new Headers();
+  const contentType = upstream.headers.get("content-type");
+  if (contentType) headers.set("Content-Type", contentType);
+  const cacheControl = upstream.headers.get("cache-control");
+  if (cacheControl) headers.set("Cache-Control", cacheControl);
+
+  return new Response(upstream.body, {
+    status: upstream.status,
+    headers,
+  });
+}

package/bin/kalcode.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env bun
+// Optional local-dev escape hatch for TLS issues. Never enable in production.
+if (process.env.KALCODE_INSECURE_TLS === "1") {
+  process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+  console.warn("Warning: insecure TLS mode enabled (KALCODE_INSECURE_TLS=1).");
+}
+
+import { main } from "../src/index.js";
+
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});
+

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@thejeetsingh/kalcode",
+  "version": "2.0.0",
+  "description": "CLI coding agent powered by NVIDIA NIM",
+  "author": "Jeet Singh",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TheJeetSingh/Kalcode.git"
+  },
+  "homepage": "https://github.com/TheJeetSingh/Kalcode#readme",
+  "bugs": {
+    "url": "https://github.com/TheJeetSingh/Kalcode/issues"
+  },
+  "keywords": [
+    "cli",
+    "coding-assistant",
+    "ai",
+    "nvidia",
+    "nim",
+    "terminal"
+  ],
+  "type": "module",
+  "bin": {
+    "kalcode": "./bin/kalcode.ts"
+  },
+  "files": [
+    "bin",
+    "src",
+    "api",
+    "README.md",
+    "LICENSE",
+    "tsconfig.json",
+    "vercel.json"
+  ],
+  "engines": {
+    "bun": ">=1.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "start": "bun run bin/kalcode.ts",
+    "dev": "bun --watch run bin/kalcode.ts",
+    "proxy": "bun run src/proxy/server.ts",
+    "proxy:dev": "bun --watch run src/proxy/server.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "chalk": "^5.4.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.7.0"
+  }
+}

package/src/agent/context.ts

@@ -0,0 +1,62 @@
+import { readFileSync, existsSync, statSync } from "fs";
+import { resolve, relative } from "path";
+import { MAX_FILE_SIZE } from "../constants.js";
+
+const addedFiles = new Map<string, string>();
+
+export function addFileToContext(filePath: string): string {
+  const abs = resolve(filePath);
+  if (!existsSync(abs)) return `File not found: ${filePath}`;
+  const stat = statSync(abs);
+  if (stat.isDirectory()) return `Cannot add directory: ${filePath}`;
+  if (stat.size > MAX_FILE_SIZE) return `File too large: ${filePath}`;
+
+  try {
+    const content = readFileSync(abs, "utf-8");
+    const rel = relative(process.cwd(), abs);
+    addedFiles.set(rel, content);
+    return `Added ${rel} (${content.split("\n").length} lines)`;
+  } catch (err) {
+    return `Error reading ${filePath}: ${err}`;
+  }
+}
+
+export function dropFileFromContext(filePath: string): string {
+  const abs = resolve(filePath);
+  const rel = relative(process.cwd(), abs);
+  if (addedFiles.has(rel)) {
+    addedFiles.delete(rel);
+    return `Dropped ${rel}`;
+  }
+  // Try matching by the raw input too
+  if (addedFiles.has(filePath)) {
+    addedFiles.delete(filePath);
+    return `Dropped ${filePath}`;
+  }
+  return `Not in context: ${filePath}`;
+}
+
+export function getContextFiles(): Map<string, string> {
+  return addedFiles;
+}
+
+export function listContextFiles(): string[] {
+  return Array.from(addedFiles.keys());
+}
+
+export function clearContextFiles(): void {
+  addedFiles.clear();
+}
+
+export function buildContextBlock(): string {
+  if (addedFiles.size === 0) return "";
+  let block = "\n\nFiles in context (provided by user for reference):\n";
+  for (const [path, content] of addedFiles) {
+    const lines = content.split("\n");
+    const preview = lines.length > 200
+      ? lines.slice(0, 200).join("\n") + `\n... (${lines.length - 200} more lines)`
+      : content;
+    block += `\n--- ${path} ---\n${preview}\n`;
+  }
+  return block;
+}

package/src/agent/history.ts

@@ -0,0 +1,70 @@
+import type { Message } from "../types.js";
+import { buildSystemPrompt } from "../constants.js";
+import { loadProjectMemory } from "./memory.js";
+import { buildContextBlock } from "./context.js";
+import { isGitRepo, gitCurrentBranch } from "../git/git.js";
+
+let messages: Message[] = [];
+
+export async function initHistory(): Promise<void> {
+  let systemContent = buildSystemPrompt(process.cwd());
+
+  // Load project memory
+  const memory = loadProjectMemory(process.cwd());
+  if (memory) {
+    systemContent += `\n\nProject conventions (from KALCODE.md):\n${memory}`;
+  }
+
+  // Git context
+  if (isGitRepo()) {
+    const branch = await gitCurrentBranch();
+    systemContent += `\n\nGit: on branch "${branch}"`;
+  }
+
+  messages = [{ role: "system", content: systemContent }];
+}
+
+export function addMessage(msg: Message): void {
+  messages.push(msg);
+}
+
+export function getMessages(): Message[] {
+  // Inject context files into the last user message if present
+  const contextBlock = buildContextBlock();
+  if (!contextBlock) return messages;
+
+  // Clone and append context to the system message
+  const result = [...messages];
+  if (result.length > 0 && result[0]!.role === "system") {
+    result[0] = { ...result[0]!, content: result[0]!.content + contextBlock };
+  }
+  return result;
+}
+
+export function getLastUserMessage(): string | null {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i]!.role === "user") {
+      return messages[i]!.content as string;
+    }
+  }
+  return null;
+}
+
+export function removeLastExchange(): void {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i]!.role === "user") {
+      messages = messages.slice(0, i);
+      return;
+    }
+  }
+}
+
+export function clearHistory(): void {
+  // Re-init is async now, but we can just reset messages
+  const systemMsg = messages.length > 0 ? messages[0]! : { role: "system" as const, content: "" };
+  messages = [systemMsg];
+}
+
+export function getMessageCount(): number {
+  return messages.filter(m => m.role !== "system").length;
+}