vibex-app 0.1.0

package/README.md

@@ -0,0 +1,44 @@
+# vibex CLI
+
+Vibex from your terminal — describe an app, a Coder + Reviewer AI pair builds it, and the
+files land in a local folder. Same account, plans, and dashboard as the web app.
+
+```sh
+npm i -g vibex-app
+
+vibex login                       # paste a token from Settings → CLI access
+vibex build "a habit tracker with streaks"
+vibex build "a trading journal" --dir ./journal
+```
+
+> npm package is `vibex-app` (the bare `vibex` name is squatted and `vibex-cli` belongs to an
+> unrelated project) — the installed command is still `vibex`.
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `vibex login [--token vx_…] [--url …]` | Verify + store your access token in `~/.vibex` |
+| `vibex build "<idea>"` | Create a project, stream the build, write files locally |
+| `vibex build --project <id>` | Rebuild / resume an existing project |
+| `vibex whoami` | Show the connected account + plan |
+| `vibex logout` | Forget the stored token |
+
+Build flags: `--dir <path>` · `--platform web|api|cli` · `--steer "<correction>"` · `--force`
+
+## Notes
+
+- Tokens are minted (and revoked) in the web app under **Settings → CLI access**; only a hash
+  is stored server-side.
+- Builds stream over the same API the web workspace uses — usage counts against your plan and
+  every run appears on your dashboard.
+- `VIBEX_API_URL` / `VIBEX_TOKEN` env vars override the stored config (useful in CI).
+
+## Develop
+
+```sh
+cd cli
+npm install
+npm run build       # tsc → dist/
+node dist/index.js --help
+```

package/dist/api.js

@@ -0,0 +1,69 @@
+// Thin client of the Vibex backend — the same endpoints the web app uses, authenticated with
+// a bearer token instead of a session cookie.
+export class ApiError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
+function headers(token) {
+    return { "content-type": "application/json", authorization: `Bearer ${token}` };
+}
+export async function apiMe(baseUrl, token) {
+    const r = await fetch(new URL("/api/me", baseUrl), { headers: headers(token) });
+    const j = (await r.json().catch(() => null));
+    if (!r.ok || !j?.ok) {
+        throw new ApiError(j?.error === "invalid_token" ? "Invalid or revoked token — mint a new one in Settings → CLI access." : `API error (${r.status})`, r.status);
+    }
+    return { user: j.user, plan: j.plan ?? "free" };
+}
+export async function createProject(baseUrl, token, spec) {
+    const r = await fetch(new URL("/api/projects", baseUrl), {
+        method: "POST",
+        headers: headers(token),
+        body: JSON.stringify({ spec }),
+    });
+    const j = (await r.json().catch(() => null));
+    if (!r.ok || !j?.ok || !j.id) {
+        throw new ApiError(j?.message ?? (j?.error === "invalid_token" ? "Invalid token — run `vibex login`." : `Couldn't create the project (${r.status}).`), r.status);
+    }
+    return { id: j.id, title: j.title ?? "" };
+}
+// Stream a build for an owned project. Yields the server's SSE events as they arrive.
+export async function* streamRun(baseUrl, token, projectId, opts) {
+    const r = await fetch(new URL("/api/run", baseUrl), {
+        method: "POST",
+        headers: headers(token),
+        body: JSON.stringify({ spec: {}, projectId, steer: opts?.steer, startIndex: opts?.startIndex ?? 0 }),
+    });
+    if (r.status === 409 || r.status === 429) {
+        const j = (await r.json().catch(() => null));
+        throw new ApiError(j?.message ?? (r.status === 429 ? "Rate limit reached — wait a moment, then retry." : "Another build is already running."), r.status);
+    }
+    if (!r.ok || !r.body)
+        throw new ApiError(`API error (${r.status}).`, r.status);
+    const reader = r.body.getReader();
+    const dec = new TextDecoder();
+    let buf = "";
+    for (;;) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        buf += dec.decode(value, { stream: true });
+        let idx;
+        while ((idx = buf.indexOf("\n\n")) !== -1) {
+            const block = buf.slice(0, idx);
+            buf = buf.slice(idx + 2);
+            const line = block.split("\n").find((l) => l.startsWith("data:"));
+            if (!line)
+                continue;
+            try {
+                yield JSON.parse(line.slice(5).trim());
+            }
+            catch {
+                /* skip malformed frame */
+            }
+        }
+    }
+}

package/dist/build.js

@@ -0,0 +1,132 @@
+// vibex build — create (or reuse) a project, stream the Coder+Reviewer build, and write the
+// generated files into a local folder. The stream is the same SSE feed the web workspace uses.
+import { mkdirSync, readdirSync, writeFileSync, existsSync } from "node:fs";
+import path from "node:path";
+import pc from "picocolors";
+import { createProject, streamRun } from "./api.js";
+import { loadConfig } from "./config.js";
+import { banner, info, stepLine, coderLine, reviewerLine, done, fileList, fail, warn, link } from "./ui.js";
+function slugify(idea) {
+    return (idea
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/(^-+|-+$)/g, "")
+        .slice(0, 40) || "vibex-app");
+}
+// Generated paths are model output — never let one escape the target folder.
+function safeJoin(root, rel) {
+    if (path.isAbsolute(rel) || /^[a-zA-Z]:/.test(rel))
+        return null;
+    const norm = path.normalize(rel);
+    if (norm.startsWith("..") || norm.includes(`..${path.sep}`))
+        return null;
+    return path.join(root, norm);
+}
+function writeFiles(dir, files) {
+    const written = [];
+    for (const f of files) {
+        const target = safeJoin(dir, f.path);
+        if (!target) {
+            warn(`skipped unsafe path: ${f.path}`);
+            continue;
+        }
+        mkdirSync(path.dirname(target), { recursive: true });
+        writeFileSync(target, f.content, "utf8");
+        written.push(f.path);
+    }
+    return written;
+}
+export async function runBuild(idea, opts) {
+    const cfg = loadConfig();
+    if (!cfg.token) {
+        fail("Not signed in — run `vibex login` first (token: Settings → CLI access on the web app).");
+        process.exit(1);
+    }
+    if (!idea.trim() && !opts.project) {
+        fail('Tell it what to build: vibex build "a habit tracker with streaks"');
+        process.exit(1);
+    }
+    const dir = path.resolve(opts.dir ?? `./${slugify(idea || opts.project || "vibex-app")}`);
+    if (existsSync(dir) && readdirSync(dir).length > 0 && !opts.force) {
+        fail(`${dir} isn't empty — pick another --dir or pass --force to write into it.`);
+        process.exit(1);
+    }
+    // 1) Project row (owned, so the run persists and shows on the web dashboard).
+    let projectId = opts.project;
+    let title = idea.trim();
+    if (!projectId) {
+        const p = await createProject(cfg.baseUrl, cfg.token, { idea: idea.trim(), platform: opts.platform ?? "web" });
+        projectId = p.id;
+        title = p.title || title;
+    }
+    banner(`Building ${pc.yellow(`"${title || projectId}"`)}`);
+    info(`server: ${cfg.baseUrl} · project: ${projectId}`);
+    // 2) Stream the build.
+    let stepsTotal = 0;
+    let files = [];
+    let tokens = 0;
+    let cost = 0;
+    let live = true;
+    let paused = null;
+    let errored = null;
+    for await (const ev of streamRun(cfg.baseUrl, cfg.token, projectId, { steer: opts.steer })) {
+        switch (ev.type) {
+            case "planned":
+                stepsTotal = ev.steps.length;
+                live = ev.live;
+                info(`planned ${ev.steps.length} steps${ev.live ? "" : " (simulated — no model key on the server)"}`);
+                break;
+            case "step_start":
+                stepLine(ev.index + 1, stepsTotal || ev.index + 1, ev.title);
+                break;
+            case "coder":
+                if (ev.path)
+                    coderLine(ev.path, ev.tokens, ev.stub);
+                break;
+            case "reviewer":
+                reviewerLine(ev.verdict, ev.note);
+                break;
+            case "usage":
+                tokens = ev.tokens;
+                cost = ev.cost;
+                break;
+            case "paused":
+                paused = `${ev.reason} — progress is saved; resume with: vibex build --project ${projectId}`;
+                break;
+            case "complete":
+                files = ev.files ?? [];
+                tokens = ev.tokens;
+                cost = ev.cost;
+                break;
+            case "error":
+                errored = ev.message;
+                break;
+            default:
+                break;
+        }
+    }
+    if (errored) {
+        fail(`The engine hit an error: ${errored}`);
+        info(`retry from the last completed step: vibex build --project ${projectId}`);
+        process.exit(1);
+    }
+    if (paused) {
+        warn(paused);
+        process.exit(2);
+    }
+    if (!files.length) {
+        fail("The build finished without producing files — check the project on the web dashboard.");
+        link("dashboard:", `${cfg.baseUrl}/result?project=${projectId}`);
+        process.exit(1);
+    }
+    // 3) Land the files.
+    mkdirSync(dir, { recursive: true });
+    const written = writeFiles(dir, files);
+    done(`Build complete ${pc.dim(`— ${(tokens / 1000).toFixed(1)}k tokens · ~$${cost.toFixed(2)}${live ? "" : " · simulated"}`)}`);
+    fileList(written, dir);
+    for (const p of written)
+        console.log(`     ${pc.dim("+")} ${p}`);
+    link("web view:", `${cfg.baseUrl}/result?project=${projectId}`);
+    if (written.includes("index.html"))
+        info(`open ${path.join(dir, "index.html")} in a browser to run it`);
+}

package/dist/config.js

@@ -0,0 +1,33 @@
+// ~/.vibex/config.json — base URL + access token. Env vars override for CI:
+// VIBEX_API_URL, VIBEX_TOKEN.
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export const DEFAULT_BASE_URL = "https://vibe-x-liart.vercel.app";
+const DIR = join(homedir(), ".vibex");
+const FILE = join(DIR, "config.json");
+export function loadConfig() {
+    let file = {};
+    try {
+        file = JSON.parse(readFileSync(FILE, "utf8"));
+    }
+    catch {
+        /* first run */
+    }
+    return {
+        baseUrl: process.env.VIBEX_API_URL || file.baseUrl || DEFAULT_BASE_URL,
+        token: process.env.VIBEX_TOKEN || file.token,
+    };
+}
+export function saveConfig(cfg) {
+    mkdirSync(DIR, { recursive: true });
+    writeFileSync(FILE, JSON.stringify(cfg, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+}
+export function clearConfig() {
+    try {
+        writeFileSync(FILE, "{}\n", "utf8");
+    }
+    catch {
+        /* nothing to clear */
+    }
+}

package/dist/index.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+// vibex — Vibex from your terminal. `vibex login` with a token from Settings → CLI access,
+// then `vibex build "an idea"` streams the Coder+Reviewer build and writes real files into a
+// local folder. Thin client of the Vibex backend: plans, limits, and dashboard all apply.
+import { createRequire } from "node:module";
+import pc from "picocolors";
+import { runLogin, runLogout, runWhoami } from "./login.js";
+import { runBuild } from "./build.js";
+import { fail } from "./ui.js";
+import { ApiError } from "./api.js";
+const require = createRequire(import.meta.url);
+const VERSION = require("../package.json").version;
+const HELP = `
+${pc.bold("vibex")} — from idea to code, in your terminal
+
+${pc.bold("Usage")}
+  vibex login [--token vx_…] [--url https://…]   connect your account
+  vibex build "<idea>" [options]                 build an app into a local folder
+  vibex whoami                                   show the signed-in account
+  vibex logout                                   forget the stored token
+
+${pc.bold("Build options")}
+  --dir <path>        target folder (default: ./<idea-slug>)
+  --platform <p>      web | api | cli            (default: web)
+  --project <id>      rebuild an existing project instead of creating one
+  --steer "<note>"    fold a correction into the build
+  --force             write into a non-empty folder
+
+${pc.bold("Examples")}
+  vibex build "a habit tracker with streaks"
+  vibex build "a trading journal" --dir ./journal --force
+
+Tokens are minted in ${pc.underline("Settings → CLI access")} on the web app.
+`;
+function parseArgs(argv) {
+    const [cmd = "help", ...rest] = argv;
+    const positional = [];
+    const flags = {};
+    for (let i = 0; i < rest.length; i++) {
+        const a = rest[i];
+        if (a.startsWith("--")) {
+            const key = a.slice(2);
+            const next = rest[i + 1];
+            if (next !== undefined && !next.startsWith("--")) {
+                flags[key] = next;
+                i++;
+            }
+            else {
+                flags[key] = true;
+            }
+        }
+        else {
+            positional.push(a);
+        }
+    }
+    return { cmd, positional, flags };
+}
+async function main() {
+    const { cmd, positional, flags } = parseArgs(process.argv.slice(2));
+    switch (cmd) {
+        case "login":
+            await runLogin({ token: typeof flags.token === "string" ? flags.token : undefined, url: typeof flags.url === "string" ? flags.url : undefined });
+            break;
+        case "logout":
+            runLogout();
+            break;
+        case "whoami":
+            await runWhoami();
+            break;
+        case "build":
+            await runBuild(positional.join(" "), {
+                dir: typeof flags.dir === "string" ? flags.dir : undefined,
+                platform: typeof flags.platform === "string" ? flags.platform : undefined,
+                project: typeof flags.project === "string" ? flags.project : undefined,
+                steer: typeof flags.steer === "string" ? flags.steer : undefined,
+                force: flags.force === true,
+            });
+            break;
+        case "--version":
+        case "-v":
+        case "version":
+            console.log(VERSION);
+            break;
+        default:
+            console.log(HELP);
+            break;
+    }
+}
+main().catch((e) => {
+    if (e instanceof ApiError)
+        fail(e.message);
+    else
+        fail(e instanceof Error ? e.message : String(e));
+    process.exit(1);
+});

package/dist/login.js

@@ -0,0 +1,40 @@
+// login / logout / whoami — token paste flow. The token is minted once in the web app
+// (Settings → CLI access) and stored in ~/.vibex/config.json (0600).
+import { createInterface } from "node:readline/promises";
+import pc from "picocolors";
+import { apiMe } from "./api.js";
+import { loadConfig, saveConfig, clearConfig, DEFAULT_BASE_URL } from "./config.js";
+import { banner, info, done, fail } from "./ui.js";
+export async function runLogin(opts) {
+    const baseUrl = opts.url || loadConfig().baseUrl || DEFAULT_BASE_URL;
+    banner("Connect your Vibex account");
+    info(`server: ${baseUrl}`);
+    info(`mint a token at ${baseUrl}/settings (CLI access), then paste it below`);
+    let token = opts.token?.trim();
+    if (!token) {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        token = (await rl.question(`\n  ${pc.bold("token")} ${pc.dim("(vx_…)")}: `)).trim();
+        rl.close();
+    }
+    if (!/^vx_[a-f0-9]{48}$/.test(token)) {
+        fail("That doesn't look like a Vibex token (expected vx_ + 48 hex characters).");
+        process.exit(1);
+    }
+    const me = await apiMe(baseUrl, token);
+    saveConfig({ baseUrl, token });
+    done(`Signed in as ${me.user.email ?? me.user.name ?? "your account"} (${me.plan} plan)`);
+    info("try: vibex build \"a habit tracker with streaks\"");
+}
+export function runLogout() {
+    clearConfig();
+    done("Token forgotten. `vibex login` to reconnect.");
+}
+export async function runWhoami() {
+    const cfg = loadConfig();
+    if (!cfg.token) {
+        fail("Not signed in — run `vibex login` first.");
+        process.exit(1);
+    }
+    const me = await apiMe(cfg.baseUrl, cfg.token);
+    console.log(`${me.user.email ?? me.user.name ?? "unknown"} ${pc.dim(`· ${me.plan} plan · ${cfg.baseUrl}`)}`);
+}

package/dist/types.js

@@ -0,0 +1,3 @@
+// Mirrors the server's public event/data shapes (app/api/run SSE + lib/steps types).
+// Kept hand-synced — the CLI is a thin client and only reads these fields.
+export {};

package/dist/ui.js

@@ -0,0 +1,48 @@
+// Terminal rendering — small, deliberate, no spinner theater. Events stream steadily, so each
+// one prints a line; color carries the role coding (coder = orange-ish, reviewer = green),
+// mirroring the web app's conversation feed.
+import pc from "picocolors";
+export const sym = {
+    mark: pc.yellow("◆"),
+    ok: pc.green("✔"),
+    warn: pc.yellow("▲"),
+    fail: pc.red("✖"),
+    pen: pc.yellow("✎"),
+    dot: pc.dim("·"),
+};
+export function banner(text) {
+    console.log(`\n${sym.mark} ${pc.bold(text)}`);
+}
+export function info(text) {
+    console.log(`  ${pc.dim(text)}`);
+}
+export function stepLine(n, of, title) {
+    console.log(`\n${pc.dim(`${String(n).padStart(2)}/${of}`)} ${pc.bold(title)}`);
+}
+export function coderLine(path, tokens, stub) {
+    if (stub) {
+        console.log(`     ${sym.warn} ${pc.yellow(`placeholder for ${path}`)} ${pc.dim("(model unavailable)")}`);
+    }
+    else {
+        console.log(`     ${sym.pen} wrote ${pc.bold(path)} ${pc.dim(`(${(tokens / 1000).toFixed(1)}k tok)`)}`);
+    }
+}
+export function reviewerLine(verdict, note) {
+    const chip = verdict === "pass" ? pc.green("PASS") : pc.yellow("REVISE");
+    console.log(`     ${chip} ${note}`);
+}
+export function done(text) {
+    console.log(`\n${sym.ok} ${pc.bold(text)}`);
+}
+export function fileList(paths, dir) {
+    console.log(`  ${pc.dim("→")} ${paths.length} file${paths.length === 1 ? "" : "s"} written to ${pc.bold(dir)}`);
+}
+export function fail(text) {
+    console.error(`\n${sym.fail} ${pc.red(text)}`);
+}
+export function warn(text) {
+    console.log(`${sym.warn} ${pc.yellow(text)}`);
+}
+export function link(label, url) {
+    console.log(`  ${pc.dim(label)} ${pc.underline(pc.cyan(url))}`);
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "vibex-app",
+  "version": "0.1.0",
+  "description": "Vibex from your terminal — describe an app, a Coder + Reviewer AI pair builds it into a local folder.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "vibex": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.17"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "tsc"
+  },
+  "dependencies": {
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "typescript": "^5.5.0"
+  }
+}