@kurtel/cli 0.1.0

package/README.md

@@ -0,0 +1,91 @@
+# Kurtel CLI
+
+Launch self-improving coding agents in the cloud — from your terminal, your
+editor, or CI. `kurtel` drops you into an interactive session (like a coding
+copilot REPL) and also exposes scriptable subcommands.
+
+> **Preview build.** The commands run end-to-end locally with realistic output,
+> but they are **not yet connected to the Kurtel cloud**. They're stubs that
+> define the experience.
+
+## Install
+
+From source (during preview):
+
+```bash
+git clone <repo> kurtel-cli && cd kurtel-cli
+npm install        # builds automatically via the prepare script
+npm link           # makes `kurtel` available everywhere (incl. the VSCode terminal)
+```
+
+Then, in any project:
+
+```bash
+kurtel
+```
+
+To remove the global link later: `npm unlink -g kurtel`.
+
+> Once published, install will be a one-liner: `npm install -g kurtel`.
+
+## Usage
+
+```text
+kurtel                       Open the interactive session
+kurtel run "<task>"          Launch a cloud agent on a task
+kurtel agents | ps           List active agents
+kurtel logs <id>             Stream an agent's logs
+kurtel status <id>           Show an agent's status
+kurtel stop <id>             Stop an agent & tear down its sandbox
+kurtel login | logout        Manage your session
+kurtel config [list|get|set] View or change local config
+kurtel init                  Initialize Kurtel in the current project
+kurtel doctor                Check your environment
+kurtel -v | --version        Print version
+kurtel -h | --help           Show help
+```
+
+### Interactive session
+
+Run `kurtel` with no arguments. Type a task to launch an agent, or use slash
+commands:
+
+```text
+/help            Show commands
+/run <task>      Launch a cloud agent
+/agents          List active agents
+/login           Sign in
+/config          Show configuration
+/clear           Clear the screen
+/exit            Quit
+```
+
+Exit with `/exit` or `Ctrl+D`.
+
+## Development
+
+```bash
+npm run dev      # run from source with tsx (no build step)
+npm run build    # compile TypeScript to dist/
+npm start        # run the compiled CLI
+```
+
+## Project layout
+
+```
+src/
+  index.ts            # entry — commander wiring + shebang
+  session/repl.ts     # interactive session
+  commands/           # one file per command group (stubs)
+    run.ts  auth.ts  agents.ts  runtime.ts  config.ts  project.ts
+  ui/                 # colors, box, banner, spinner (zero-dep)
+  lib/                # version, config (~/.kurtel/config.json), sample data
+```
+
+## Notes
+
+- Built as an ESM TypeScript project targeting Node ≥ 18.
+- Only one runtime dependency (`commander`); the terminal UI is hand-rolled with
+  ANSI escapes and honors `NO_COLOR`.
+- Local config lives at `~/.kurtel/config.json`; `kurtel init` writes a
+  project-level `.kurtel/config.json`.

package/dist/commands/_shared.js

@@ -0,0 +1,7 @@
+import { c, symbols } from "../ui/colors.js";
+export function previewNotice(what) {
+    console.log(`${c.yellow(symbols.warn)} ${c.dim(`${what} isn't wired up to the Kurtel cloud yet — this is a preview build.`)}`);
+}
+export function heading(text) {
+    console.log(`\n${c.indigoBold(text)}`);
+}

package/dist/commands/agents.js

@@ -0,0 +1,28 @@
+import { c } from "../ui/colors.js";
+import { SAMPLE_AGENTS, statusColor, levelBadge, } from "../lib/agents.js";
+import { previewNotice } from "./_shared.js";
+function pad(s, width) {
+    // pad based on visible length (strip ANSI)
+    // eslint-disable-next-line no-control-regex
+    const len = s.replace(/\x1b\[[0-9;]*m/g, "").length;
+    return s + " ".repeat(Math.max(0, width - len));
+}
+export function agentsCommand() {
+    console.log("");
+    const header = pad(c.gray("ID"), 12) +
+        pad(c.gray("LEVEL"), 9) +
+        pad(c.gray("STATUS"), 14) +
+        pad(c.gray("AGE"), 7) +
+        c.gray("TASK");
+    console.log(header);
+    for (const a of SAMPLE_AGENTS) {
+        const row = pad(c.indigo(a.id), 12) +
+            pad(levelBadge(a.level), 9) +
+            pad(statusColor(a.status), 14) +
+            pad(c.dim(a.age), 7) +
+            c.white(a.task);
+        console.log(row);
+    }
+    console.log("");
+    previewNotice("Listing agents");
+}

package/dist/commands/auth.js

@@ -0,0 +1,35 @@
+import { c, symbols } from "../ui/colors.js";
+import { Spinner, sleep } from "../ui/spinner.js";
+import { loadConfig, saveConfig } from "../lib/config.js";
+import { previewNotice } from "./_shared.js";
+export async function loginCommand() {
+    const config = loadConfig();
+    if (config.loggedIn) {
+        console.log(`${symbols.check} Already signed in as ${c.indigo(config.account ?? "you@example.com")}.`);
+        return;
+    }
+    console.log("");
+    console.log(`${c.indigo(symbols.arrow)} Sign in to Kurtel — we'll open your browser to authorize.`);
+    const fakeUrl = "https://kurtel.ai/cli/auth?code=KRTL-PREVIEW";
+    console.log(`  ${c.dim(fakeUrl)}`);
+    console.log("");
+    const spin = new Spinner("Waiting for browser authorization…").start();
+    await sleep(1200);
+    spin.info("Authorization step is a preview stub.");
+    config.loggedIn = true;
+    config.account = "you@example.com";
+    saveConfig(config);
+    console.log(`${symbols.check} Signed in as ${c.indigo(config.account)} ${c.dim("(local preview session)")}`);
+    previewNotice("Authentication");
+}
+export async function logoutCommand() {
+    const config = loadConfig();
+    if (!config.loggedIn) {
+        console.log(`${c.dim("You're not signed in.")}`);
+        return;
+    }
+    config.loggedIn = false;
+    delete config.account;
+    saveConfig(config);
+    console.log(`${symbols.check} Signed out.`);
+}

package/dist/commands/config.js

@@ -0,0 +1,35 @@
+import { c, symbols } from "../ui/colors.js";
+import { loadConfig, setConfigValue, configPath, } from "../lib/config.js";
+export function configCommand(action, key, value) {
+    if (!action || action === "list") {
+        const config = loadConfig();
+        console.log(`\n${c.dim("config")} ${c.dim(configPath())}\n`);
+        for (const [k, v] of Object.entries(config)) {
+            console.log(`${c.indigo(k.padEnd(14))} ${c.white(String(v))}`);
+        }
+        console.log("");
+        return;
+    }
+    if (action === "get") {
+        if (!key) {
+            console.log(`${c.red(symbols.cross)} Usage: ${c.indigo("kurtel config get <key>")}`);
+            process.exitCode = 1;
+            return;
+        }
+        const config = loadConfig();
+        console.log(String(config[key] ?? c.dim("(unset)")));
+        return;
+    }
+    if (action === "set") {
+        if (!key || value === undefined) {
+            console.log(`${c.red(symbols.cross)} Usage: ${c.indigo("kurtel config set <key> <value>")}`);
+            process.exitCode = 1;
+            return;
+        }
+        setConfigValue(key, value);
+        console.log(`${symbols.check} Set ${c.indigo(key)} = ${c.white(value)}`);
+        return;
+    }
+    console.log(`${c.red(symbols.cross)} Unknown action ${c.white(action)}. Try ${c.indigo("list")}, ${c.indigo("get")}, or ${c.indigo("set")}.`);
+    process.exitCode = 1;
+}

package/dist/commands/project.js

@@ -0,0 +1,47 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { c, symbols } from "../ui/colors.js";
+import { Spinner, sleep } from "../ui/spinner.js";
+import { getVersion } from "../lib/version.js";
+import { loadConfig } from "../lib/config.js";
+export async function initCommand() {
+    const dir = join(process.cwd(), ".kurtel");
+    const file = join(dir, "config.json");
+    if (existsSync(file)) {
+        console.log(`${c.yellow(symbols.warn)} ${c.dim(".kurtel/config.json already exists.")}`);
+        return;
+    }
+    const spin = new Spinner("Initializing Kurtel in this project…").start();
+    await sleep(500);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    const template = {
+        version: 1,
+        engine: "kurtel-sota",
+        sandbox: { isolated: true, ephemeral: true },
+        review: { openPullRequests: true },
+        learn: { shareTeamPatterns: true },
+    };
+    writeFileSync(file, JSON.stringify(template, null, 2) + "\n", "utf8");
+    spin.succeed("Created .kurtel/config.json");
+    console.log(`\n${c.dim("Next:")} ${c.indigo("kurtel login")} ${c.dim("then")} ${c.indigo('kurtel run "your first task"')}`);
+}
+export function doctorCommand() {
+    const config = loadConfig();
+    const checks = [
+        [true, `Kurtel CLI v${getVersion()}`],
+        [true, `Node.js ${process.version}`],
+        [
+            process.stdout.isTTY ?? false,
+            `Interactive TTY ${process.stdout.isTTY ? "" : "(not detected — interactive mode limited)"}`,
+        ],
+        [config.loggedIn, config.loggedIn ? "Signed in" : "Not signed in (run: kurtel login)"],
+        [false, "Cloud connectivity (preview — not yet enabled)"],
+    ];
+    console.log(`\n${c.indigoBold("Kurtel doctor")}\n`);
+    for (const [ok, label] of checks) {
+        const mark = ok ? symbols.check : c.yellow(symbols.warn);
+        console.log(`  ${mark} ${ok ? c.white(label) : c.dim(label)}`);
+    }
+    console.log("");
+}

package/dist/commands/run.js

@@ -0,0 +1,27 @@
+import { c, symbols } from "../ui/colors.js";
+import { Spinner, sleep } from "../ui/spinner.js";
+import { previewNotice } from "./_shared.js";
+export async function runCommand(task, opts) {
+    if (!task || task.trim() === "") {
+        console.log(`${c.red(symbols.cross)} Provide a task, e.g. ${c.indigo('kurtel run "fix flaky auth test"')}`);
+        process.exitCode = 1;
+        return;
+    }
+    const id = "agent-" + Math.random().toString(16).slice(2, 6);
+    const repo = opts.repo ?? "(current repo)";
+    console.log("");
+    console.log(`${c.gray("task")}   ${c.white(task)}`);
+    console.log(`${c.gray("repo")}   ${c.white(repo)}`);
+    console.log(`${c.gray("branch")} ${c.white(opts.branch ?? "main")}`);
+    console.log("");
+    const spin = new Spinner("Provisioning isolated sandbox…").start();
+    await sleep(700);
+    spin.update("Booting agent (codex + claude-code)…");
+    await sleep(700);
+    spin.update("Cloning repository into sandbox…");
+    await sleep(600);
+    spin.succeed(`Launched ${c.indigo(id)} ${c.dim(`(${opts.detach ? "detached" : "attached"})`)}`);
+    console.log("");
+    previewNotice("Launching agents");
+    console.log(`${c.dim("Once connected, follow it with")} ${c.indigo(`kurtel logs ${id}`)}${c.dim(".")}`);
+}

package/dist/commands/runtime.js

@@ -0,0 +1,50 @@
+import { c } from "../ui/colors.js";
+import { Spinner, sleep } from "../ui/spinner.js";
+import { SAMPLE_AGENTS, statusColor, levelBadge } from "../lib/agents.js";
+import { previewNotice } from "./_shared.js";
+function findAgent(id) {
+    return SAMPLE_AGENTS.find((a) => a.id === id) ?? SAMPLE_AGENTS[0];
+}
+const FAKE_LOG_LINES = [
+    ["plan", "Reading repository structure and conventions"],
+    ["plan", "Drafting change set across 4 files"],
+    ["edit", "src/webhooks/handler.ts — add idempotency guard"],
+    ["test", "Running test suite in sandbox"],
+    ["learn", "Captured pattern: prefer repository-scoped idempotency keys"],
+    ["done", "Opened pull request #482"],
+];
+export async function logsCommand(id) {
+    const agent = findAgent(id);
+    console.log(`\n${c.dim("Streaming logs for")} ${c.indigo(agent.id)} ${c.dim(`· ${agent.repo}`)}\n`);
+    for (const [tag, msg] of FAKE_LOG_LINES) {
+        const ts = c.dim(new Date().toLocaleTimeString());
+        const label = tag === "learn"
+            ? c.cyan(`[${tag}]`)
+            : tag === "done"
+                ? c.green(`[${tag}]`)
+                : c.indigo(`[${tag}]`);
+        console.log(`${ts} ${label} ${c.white(msg)}`);
+        await sleep(450);
+    }
+    console.log("");
+    previewNotice("Live logs");
+}
+export function statusCommand(id) {
+    const a = findAgent(id);
+    console.log("");
+    console.log(`${c.gray("id")}       ${c.indigo(a.id)}`);
+    console.log(`${c.gray("task")}     ${c.white(a.task)}`);
+    console.log(`${c.gray("repo")}     ${c.white(a.repo)}`);
+    console.log(`${c.gray("level")}    ${levelBadge(a.level)}`);
+    console.log(`${c.gray("status")}   ${statusColor(a.status)}`);
+    console.log(`${c.gray("progress")} ${c.white(a.progress + "%")}`);
+    console.log("");
+    previewNotice("Agent status");
+}
+export async function stopCommand(id) {
+    const a = findAgent(id);
+    const spin = new Spinner(`Stopping ${c.indigo(a.id)} and tearing down sandbox…`).start();
+    await sleep(800);
+    spin.succeed(`Stopped ${c.indigo(a.id)} ${c.dim("· sandbox destroyed")}`);
+    previewNotice("Stopping agents");
+}

package/dist/index.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { getVersion } from "./lib/version.js";
+import { loadConfig } from "./lib/config.js";
+import { c, symbols } from "./ui/colors.js";
+import { startSession } from "./session/repl.js";
+import { runCommand } from "./commands/run.js";
+import { loginCommand, logoutCommand } from "./commands/auth.js";
+import { agentsCommand } from "./commands/agents.js";
+import { logsCommand, statusCommand, stopCommand } from "./commands/runtime.js";
+import { configCommand } from "./commands/config.js";
+import { initCommand, doctorCommand } from "./commands/project.js";
+const program = new Command();
+program
+    .name("kurtel")
+    .description("Launch self-improving coding agents in the cloud.")
+    .version(getVersion(), "-v, --version", "Print the CLI version")
+    .helpOption("-h, --help", "Show help")
+    .addHelpText("afterAll", `\n${c.dim("Run")} ${c.indigo("kurtel")} ${c.dim("with no arguments to open the interactive session.")}\n`);
+// Default action: interactive session
+program.action(async () => {
+    const config = loadConfig();
+    await startSession(String(config.engine));
+});
+program
+    .command("run")
+    .description("Launch a cloud agent on a task")
+    .argument("[task...]", "What you want the agent to do")
+    .option("-r, --repo <repo>", "Target repository")
+    .option("-b, --branch <branch>", "Base branch", "main")
+    .option("-d, --detach", "Launch without attaching to logs", false)
+    .action(async (taskParts, opts) => {
+    await runCommand((taskParts ?? []).join(" "), opts);
+});
+program
+    .command("agents")
+    .alias("ps")
+    .description("List active agents")
+    .action(() => agentsCommand());
+program
+    .command("logs")
+    .description("Stream an agent's logs")
+    .argument("<id>", "Agent id (e.g. agent-7f3a)")
+    .action(async (id) => logsCommand(id));
+program
+    .command("status")
+    .description("Show an agent's status")
+    .argument("<id>", "Agent id")
+    .action((id) => statusCommand(id));
+program
+    .command("stop")
+    .description("Stop an agent and tear down its sandbox")
+    .argument("<id>", "Agent id")
+    .action(async (id) => stopCommand(id));
+program
+    .command("login")
+    .description("Sign in to Kurtel")
+    .action(async () => loginCommand());
+program
+    .command("logout")
+    .description("Sign out")
+    .action(async () => logoutCommand());
+program
+    .command("config")
+    .description("View or change local configuration")
+    .argument("[action]", "list | get | set", "list")
+    .argument("[key]", "Config key")
+    .argument("[value]", "Value (for set)")
+    .action((action, key, value) => configCommand(action, key, value));
+program
+    .command("init")
+    .description("Initialize Kurtel in the current project")
+    .action(async () => initCommand());
+program
+    .command("doctor")
+    .description("Check your environment")
+    .action(() => doctorCommand());
+async function main() {
+    try {
+        await program.parseAsync(process.argv);
+    }
+    catch (err) {
+        console.error(`${c.red(symbols.cross)} ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+}
+main();

package/dist/lib/agents.js

@@ -0,0 +1,54 @@
+// Stubbed agent data. In the real product this comes from the Kurtel cloud API.
+// For now it gives the commands something realistic to render.
+import { c } from "../ui/colors.js";
+export const SAMPLE_AGENTS = [
+    {
+        id: "agent-7f3a",
+        task: "Add idempotency keys to billing webhooks",
+        repo: "billing-service",
+        level: "senior",
+        status: "running",
+        progress: 82,
+        age: "3m",
+    },
+    {
+        id: "agent-2c9d",
+        task: "Migrate dashboard to server components",
+        repo: "web-dashboard",
+        level: "mid",
+        status: "learning",
+        progress: 46,
+        age: "11m",
+    },
+    {
+        id: "agent-b41e",
+        task: "Tighten Terraform IAM scopes",
+        repo: "infra-terraform",
+        level: "junior",
+        status: "queued",
+        progress: 0,
+        age: "30s",
+    },
+];
+export function statusColor(status) {
+    switch (status) {
+        case "running":
+            return c.indigo("● running");
+        case "learning":
+            return c.cyan("● learning");
+        case "queued":
+            return c.gray("○ queued");
+        case "done":
+            return c.green("✔ done");
+        case "failed":
+            return c.red("✖ failed");
+    }
+}
+export function levelBadge(level) {
+    const label = level.toUpperCase();
+    if (level === "senior")
+        return c.indigo(label);
+    if (level === "mid")
+        return c.ash(label);
+    return c.gray(label);
+}

package/dist/lib/config.js

@@ -0,0 +1,35 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
+const DIR = join(homedir(), ".kurtel");
+const FILE = join(DIR, "config.json");
+const DEFAULTS = {
+    engine: "kurtel-sota (codex + claude-code)",
+    defaultBranch: "main",
+    loggedIn: false,
+};
+export function configPath() {
+    return FILE;
+}
+export function loadConfig() {
+    try {
+        if (!existsSync(FILE))
+            return { ...DEFAULTS };
+        const data = JSON.parse(readFileSync(FILE, "utf8"));
+        return { ...DEFAULTS, ...data };
+    }
+    catch {
+        return { ...DEFAULTS };
+    }
+}
+export function saveConfig(config) {
+    if (!existsSync(DIR))
+        mkdirSync(DIR, { recursive: true });
+    writeFileSync(FILE, JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+export function setConfigValue(key, value) {
+    const config = loadConfig();
+    config[key] = value;
+    saveConfig(config);
+    return config;
+}

package/dist/lib/version.js

@@ -0,0 +1,19 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+let cached = null;
+export function getVersion() {
+    if (cached)
+        return cached;
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        // dist/lib/version.js -> ../../package.json
+        const pkgPath = join(here, "..", "..", "package.json");
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        cached = pkg.version ?? "0.0.0";
+    }
+    catch {
+        cached = "0.0.0";
+    }
+    return cached;
+}

package/dist/session/repl.js

@@ -0,0 +1,127 @@
+import * as readline from "node:readline";
+import { c, symbols } from "../ui/colors.js";
+import { banner, welcomeBox } from "../ui/banner.js";
+import { Spinner, sleep } from "../ui/spinner.js";
+import { loadConfig } from "../lib/config.js";
+import { agentsCommand } from "../commands/agents.js";
+import { loginCommand } from "../commands/auth.js";
+import { configCommand } from "../commands/config.js";
+import { previewNotice } from "../commands/_shared.js";
+const SLASH_COMMANDS = [
+    ["/help", "Show this help"],
+    ["/run <task>", "Launch a cloud agent on a task"],
+    ["/agents", "List active agents"],
+    ["/login", "Sign in to Kurtel"],
+    ["/config", "Show local configuration"],
+    ["/clear", "Clear the screen"],
+    ["/exit", "Quit the session"],
+];
+function prompt() {
+    return `${c.indigo("kurtel")} ${c.indigo(symbols.arrow)} `;
+}
+function printHelp() {
+    console.log("");
+    console.log(c.indigoBold("Commands"));
+    for (const [cmd, desc] of SLASH_COMMANDS) {
+        console.log(`  ${c.indigo(cmd.padEnd(16))} ${c.dim(desc)}`);
+    }
+    console.log("");
+    console.log(c.dim("Anything else you type is treated as a task and launches an agent."));
+    console.log("");
+}
+async function launchFromPrompt(task) {
+    const id = "agent-" + Math.random().toString(16).slice(2, 6);
+    const spin = new Spinner("Provisioning sandbox & booting agent…").start();
+    await sleep(700);
+    spin.update("Planning approach…");
+    await sleep(700);
+    spin.succeed(`Queued ${c.indigo(id)} for: ${c.white(task)}`);
+    previewNotice("Launching agents");
+}
+export async function startSession(model) {
+    console.log(banner());
+    console.log(welcomeBox(process.cwd(), model));
+    console.log("");
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: prompt(),
+        completer: (line) => {
+            const hits = SLASH_COMMANDS.map(([cmd]) => cmd.split(" ")[0]).filter((cmd) => cmd.startsWith(line));
+            return [hits.length ? hits : [], line];
+        },
+    });
+    rl.prompt();
+    rl.on("line", async (input) => {
+        const line = input.trim();
+        if (line === "") {
+            rl.prompt();
+            return;
+        }
+        if (line.startsWith("/")) {
+            const [cmd, ...rest] = line.slice(1).split(" ");
+            const arg = rest.join(" ").trim();
+            switch (cmd) {
+                case "help":
+                case "?":
+                    printHelp();
+                    break;
+                case "exit":
+                case "quit":
+                case "q":
+                    rl.close();
+                    return;
+                case "clear":
+                    console.clear();
+                    console.log(banner());
+                    break;
+                case "agents":
+                case "ps":
+                    rl.pause();
+                    agentsCommand();
+                    rl.resume();
+                    break;
+                case "login":
+                    rl.pause();
+                    await loginCommand();
+                    rl.resume();
+                    break;
+                case "config":
+                    rl.pause();
+                    configCommand("list");
+                    rl.resume();
+                    break;
+                case "run":
+                    rl.pause();
+                    if (!arg) {
+                        console.log(`${c.red(symbols.cross)} Usage: ${c.indigo("/run <task>")}`);
+                    }
+                    else {
+                        await launchFromPrompt(arg);
+                    }
+                    rl.resume();
+                    break;
+                default:
+                    console.log(`${c.red(symbols.cross)} Unknown command ${c.white("/" + cmd)}. Type ${c.indigo("/help")}.`);
+            }
+            rl.prompt();
+            return;
+        }
+        // Free text -> treat as a task
+        rl.pause();
+        await launchFromPrompt(line);
+        rl.resume();
+        rl.prompt();
+    });
+    rl.on("close", () => {
+        console.log(`\n${c.dim("See you soon. ")}${c.indigo("›")}\n`);
+        process.exit(0);
+    });
+    // Ctrl+C: confirm-style behavior — first clears line, prompt again.
+    rl.on("SIGINT", () => {
+        console.log(`\n${c.dim("(use /exit or Ctrl+D to quit)")}`);
+        rl.prompt();
+    });
+    // Touch config so a fresh user has it.
+    loadConfig();
+}

package/dist/ui/banner.js

@@ -0,0 +1,28 @@
+import { c, symbols } from "./colors.js";
+import { box } from "./box.js";
+import { getVersion } from "../lib/version.js";
+const wordmark = [
+    "  _  __         _       _ ",
+    " | |/ /  _ _ _ | |_ ___| |",
+    " | ' <  | '_| || |  _/ -_) |",
+    " |_|\\_\\ |_|  \\_,_|\\__\\___|_|",
+];
+export function banner() {
+    const art = wordmark.map((l) => c.indigoBold(l)).join("\n");
+    const tag = c.gray("  self-improving coding agents in the cloud");
+    const ver = c.dim(`  v${getVersion()}`);
+    return `\n${art}\n${tag}${ver}\n`;
+}
+export function welcomeBox(cwd, model) {
+    const lines = [
+        `${c.indigo(symbols.arrow)} ${c.bold("Welcome to Kurtel")} ${c.dim("(preview)")}`,
+        "",
+        `${c.gray("cwd")}    ${c.white(cwd)}`,
+        `${c.gray("engine")} ${c.white(model)}`,
+        `${c.gray("status")} ${c.yellow("● not connected")} ${c.dim("— commands are stubs for now")}`,
+        "",
+        `${c.dim("Type a task to launch an agent, or")} ${c.indigo("/help")} ${c.dim("for commands.")}`,
+        `${c.dim("Exit with")} ${c.indigo("/exit")} ${c.dim("or Ctrl+D.")}`,
+    ];
+    return box(lines, { borderColor: c.indigo, padding: 1 });
+}

package/dist/ui/box.js

@@ -0,0 +1,23 @@
+import { c } from "./colors.js";
+// Strip ANSI escapes to measure visible width.
+function visibleLength(s) {
+    // eslint-disable-next-line no-control-regex
+    return s.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+export function box(lines, opts = {}) {
+    const padding = opts.padding ?? 1;
+    const color = opts.borderColor ?? c.indigo;
+    const contentWidth = Math.max(...lines.map(visibleLength), opts.title ? visibleLength(opts.title) + 2 : 0);
+    const innerWidth = contentWidth + padding * 2;
+    const horizontal = "─".repeat(innerWidth);
+    const top = opts.title
+        ? color("╭─ ") + c.bold(opts.title) + color(" " + "─".repeat(Math.max(0, innerWidth - visibleLength(opts.title) - 3)) + "╮")
+        : color("╭" + horizontal + "╮");
+    const bottom = color("╰" + horizontal + "╯");
+    const pad = " ".repeat(padding);
+    const body = lines.map((line) => {
+        const fill = " ".repeat(Math.max(0, contentWidth - visibleLength(line)));
+        return color("│") + pad + line + fill + pad + color("│");
+    });
+    return [top, ...body, bottom].join("\n");
+}

package/dist/ui/colors.js

@@ -0,0 +1,41 @@
+// Lightweight ANSI styling — no dependencies.
+// Honors NO_COLOR and non-TTY output.
+const enabled = process.env.NO_COLOR === undefined &&
+    process.env.TERM !== "dumb" &&
+    (process.stdout.isTTY ?? false);
+function wrap(open, close = "\x1b[0m") {
+    return (s) => (enabled ? `${open}${s}${close}` : String(s));
+}
+// Brand indigo (#6798ff) via 24-bit truecolor, with graceful no-op fallback.
+const indigoOpen = "\x1b[38;2;103;152;255m";
+export const c = {
+    enabled,
+    reset: "\x1b[0m",
+    bold: wrap("\x1b[1m"),
+    dim: wrap("\x1b[2m"),
+    italic: wrap("\x1b[3m"),
+    underline: wrap("\x1b[4m"),
+    // brand
+    indigo: wrap(indigoOpen),
+    indigoBold: wrap(`\x1b[1m${indigoOpen}`),
+    // neutrals / semantic
+    white: wrap("\x1b[97m"),
+    gray: wrap("\x1b[90m"),
+    ash: wrap("\x1b[37m"),
+    green: wrap("\x1b[32m"),
+    yellow: wrap("\x1b[33m"),
+    red: wrap("\x1b[31m"),
+    cyan: wrap("\x1b[36m"),
+    // background
+    bgIndigo: wrap("\x1b[48;2;103;152;255m\x1b[30m"),
+};
+export const symbols = {
+    dot: "·",
+    arrow: "›",
+    check: c.green("✔"),
+    cross: c.red("✖"),
+    warn: c.yellow("!"),
+    info: c.indigo("●"),
+    bullet: c.gray("•"),
+    spinnerFrames: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+};

package/dist/ui/spinner.js

@@ -0,0 +1,54 @@
+import { c, symbols } from "./colors.js";
+export class Spinner {
+    timer = null;
+    frame = 0;
+    text;
+    active = false;
+    constructor(text) {
+        this.text = text;
+    }
+    start() {
+        if (!process.stdout.isTTY) {
+            process.stdout.write(`${c.indigo(symbols.info)} ${this.text}\n`);
+            return this;
+        }
+        this.active = true;
+        process.stdout.write("\x1b[?25l"); // hide cursor
+        this.timer = setInterval(() => {
+            const f = symbols.spinnerFrames[this.frame % symbols.spinnerFrames.length];
+            process.stdout.write(`\r${c.indigo(f)} ${this.text}`);
+            this.frame++;
+        }, 80);
+        return this;
+    }
+    update(text) {
+        this.text = text;
+    }
+    clearLine() {
+        if (this.active)
+            process.stdout.write("\r\x1b[K");
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.clearLine();
+        if (this.active)
+            process.stdout.write("\x1b[?25h"); // show cursor
+        this.active = false;
+    }
+    succeed(text) {
+        this.stop();
+        process.stdout.write(`${symbols.check} ${text ?? this.text}\n`);
+    }
+    fail(text) {
+        this.stop();
+        process.stdout.write(`${symbols.cross} ${text ?? this.text}\n`);
+    }
+    info(text) {
+        this.stop();
+        process.stdout.write(`${symbols.info} ${text ?? this.text}\n`);
+    }
+}
+export function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@kurtel/cli",
+  "version": "0.1.0",
+  "description": "Launch self-improving coding agents in the cloud — the Kurtel CLI.",
+  "type": "module",
+  "bin": {
+    "kurtel": "dist/index.js"
+  },
+  "publishConfig": { "access": "public" },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "kurtel",
+    "ai",
+    "coding-agent",
+    "cli",
+    "cloud",
+    "agents"
+  ],
+  "license": "UNLICENSED",
+  "dependencies": {
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.7.0",
+    "tsx": "^4.19.1",
+    "typescript": "^5.6.2"
+  }
+}