@anna-ai/cli 0.1.12 → 0.1.14

package/dist/executa-dev-BhouP8jh.js

@@ -0,0 +1,212 @@
+import { parseExecutaSpec } from "./dev-BfLGxpiT.js";
+import { isAbsolute, resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { bold, cyan, dim, green, red, yellow } from "kleur/colors";
+import * as readline from "node:readline";
+import { createInterface as createInterface$1 } from "node:readline/promises";
+
+//#region src/commands/executa-dev.ts
+/**
+* Mutable hook the REPL installs while it's waiting at a prompt, so
+* out-of-band stderr lines from the executa subprocess don't garble
+* the prompt. When set, the stderr sink clears the current readline
+* line on stdout, prints the message, then asks readline to redraw
+* the prompt + any pending user input.
+*/
+let activeRepl = null;
+async function runExecutaDev(opts) {
+	const cwd = process.cwd();
+	const dir = opts.dir ? isAbsolute(opts.dir) ? opts.dir : resolve(cwd, opts.dir) : cwd;
+	if (!existsSync(dir)) {
+		console.error(red(`✗ dir not found: ${dir}`));
+		return 2;
+	}
+	const specStr = opts.spec ? prependDirIfMissing(opts.spec, dir) : `dir=${dir}`;
+	const parsed = parseExecutaSpec(specStr, cwd);
+	if (parsed instanceof Error) {
+		console.error(red(`✗ ${parsed.message}`));
+		return 2;
+	}
+	if (!parsed.command || parsed.command.length === 0) {
+		console.error(red(`✗ could not derive a launch command for ${dir}`));
+		return 2;
+	}
+	const oneShot = !!(opts.describe || opts.health || opts.invoke);
+	const quiet = oneShot && (opts.json ?? false);
+	const { SamplingBridge } = await import("./sampling-3EfSlDHM.js");
+	const sampling = opts.noSampling ? new SamplingBridge({ mode: "off" }) : opts.mockSampling ? new SamplingBridge({
+		mode: "mock",
+		mockFile: opts.mockSampling
+	}) : opts.appSlug ? new SamplingBridge({
+		mode: "real",
+		account: opts.samplingAccount,
+		appSlug: opts.appSlug
+	}) : new SamplingBridge({ mode: "off" });
+	const { AgentBridge } = await import("./agent-DUmINbo4.js");
+	const agent = opts.noAgent ? new AgentBridge({ mode: "off" }) : opts.mockAgent ? new AgentBridge({
+		mode: "mock",
+		mockFile: opts.mockAgent
+	}) : opts.appSlug ? new AgentBridge({
+		mode: "real",
+		account: opts.agentAccount ?? opts.samplingAccount,
+		appSlug: opts.appSlug
+	}) : new AgentBridge({ mode: "off" });
+	const { StorageBridge } = await import("./storage-CnWTZqq_.js");
+	const storageMode = opts.storage ?? (opts.mockStorage ? "mock" : "memory");
+	const storage = new StorageBridge({
+		mode: storageMode,
+		mockFile: opts.mockStorage,
+		account: opts.storageAccount ?? opts.samplingAccount,
+		appSlug: opts.appSlug,
+		scopes: opts.storageScopes ? opts.storageScopes.split(",").map((s) => s.trim()).filter(Boolean) : void 0,
+		pluginName: parsed.tool_id
+	});
+	const { ExecutaRunner } = await import("./runner-Bral1LFW.js");
+	const runner = new ExecutaRunner({
+		command: parsed.command,
+		cwd: parsed.project_dir,
+		sampling,
+		agent,
+		storage,
+		onStderr: (line) => {
+			const text = quiet ? `${line}\n` : dim(`[executa] ${line}\n`);
+			writeStderrCooperative(text);
+		}
+	});
+	if (!quiet) {
+		console.log(bold(cyan("anna-app executa dev")));
+		console.log(`  tool_id   ${dim(parsed.tool_id)}`);
+		console.log(`  dir       ${dim(parsed.project_dir)}`);
+		console.log(`  command   ${dim(parsed.command.join(" "))}`);
+		console.log(`  sampling  ${dim(opts.noSampling ? "disabled (--no-sampling)" : opts.mockSampling ? `mock (${opts.mockSampling})` : opts.appSlug ? `real → app_slug=${opts.appSlug}` : "disabled (no fixture, no --app-slug)")}`);
+		console.log(`  agent     ${dim(opts.noAgent ? "disabled (--no-agent)" : opts.mockAgent ? `mock (${opts.mockAgent})` : opts.appSlug ? `real → app_slug=${opts.appSlug}` : "disabled (no fixture, no --app-slug)")}`);
+		console.log(`  storage   ${dim(storageMode === "mock" ? `mock (${opts.mockStorage ?? "<no-fixture>"})` : storageMode === "real" ? `real → app_slug=${opts.appSlug ?? "<unset>"}` : storageMode)}`);
+	}
+	let init;
+	try {
+		init = await runner.start();
+	} catch (e) {
+		console.error(red(`✗ executa failed to start: ${e.message}`));
+		return 2;
+	}
+	if (!quiet) console.log(`  ${green("✓")} negotiated protocol ${bold(init.protocolVersion)}`);
+	let exitCode = 0;
+	try {
+		if (oneShot) exitCode = await runOneShot(runner, opts, quiet);
+		else exitCode = await runRepl(runner);
+	} finally {
+		await runner.stop();
+	}
+	return exitCode;
+}
+function prependDirIfMissing(spec, dir) {
+	if (/\bdir\s*=/.test(spec)) return spec;
+	return `dir=${dir},${spec}`;
+}
+async function runOneShot(runner, opts, quiet) {
+	const print = (v) => {
+		process.stdout.write(`${JSON.stringify(v, null, quiet ? 0 : 2)}\n`);
+	};
+	try {
+		if (opts.describe) {
+			print(await runner.describe());
+			return 0;
+		}
+		if (opts.health) {
+			print(await runner.health());
+			return 0;
+		}
+		if (opts.invoke) {
+			let args = {};
+			if (opts.args) try {
+				const parsed = JSON.parse(opts.args);
+				if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("--args must be a JSON object");
+				args = parsed;
+			} catch (e) {
+				console.error(red(`✗ --args: ${e.message}`));
+				return 2;
+			}
+			print(await runner.invoke(opts.invoke, args));
+			return 0;
+		}
+		return 0;
+	} catch (e) {
+		console.error(red(`✗ ${e.message}`));
+		return 1;
+	}
+}
+async function runRepl(runner) {
+	const rl = createInterface$1({
+		input: process.stdin,
+		output: process.stdout
+	});
+	console.log(yellow("  REPL ready. Commands: describe | health | invoke <tool> <json?> | quit"));
+	activeRepl = { rl };
+	for (;;) {
+		let line;
+		try {
+			line = (await rl.question(cyan("executa> "))).trim();
+		} catch {
+			break;
+		}
+		if (!line) continue;
+		if (line === "quit" || line === "exit" || line === ".q") break;
+		try {
+			if (line === "describe") {
+				const out = await runner.describe();
+				process.stdout.write(`${JSON.stringify(out, null, 2)}\n`);
+			} else if (line === "health") {
+				const out = await runner.health();
+				process.stdout.write(`${JSON.stringify(out, null, 2)}\n`);
+			} else if (line.startsWith("invoke")) {
+				const rest = line.slice(6).trim();
+				const sp = rest.indexOf(" ");
+				const tool = sp === -1 ? rest : rest.slice(0, sp);
+				const argsStr = sp === -1 ? "{}" : rest.slice(sp + 1).trim() || "{}";
+				if (!tool) {
+					console.error(red("usage: invoke <tool> <json-args?>"));
+					continue;
+				}
+				let args;
+				try {
+					const parsed = JSON.parse(argsStr);
+					if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("args must be a JSON object");
+					args = parsed;
+				} catch (e) {
+					console.error(red(`bad args: ${e.message}`));
+					continue;
+				}
+				const out = await runner.invoke(tool, args);
+				process.stdout.write(`${JSON.stringify(out, null, 2)}\n`);
+			} else console.error(yellow(`unknown command: ${line}`));
+		} catch (e) {
+			console.error(red(`✗ ${e.message}`));
+		}
+	}
+	activeRepl = null;
+	rl.close();
+	return 0;
+}
+/**
+* Write to stderr without trampling the REPL prompt. When the REPL is
+* idle (no `activeRepl`) or stdout is not a TTY, this is a plain
+* `process.stderr.write`. When the REPL is at a prompt, we clear the
+* prompt line on stdout, emit the stderr text, then redraw the prompt
+* with any user input the reader had already buffered.
+*/
+function writeStderrCooperative(text) {
+	const repl = activeRepl;
+	if (!repl || !process.stdout.isTTY) {
+		process.stderr.write(text);
+		return;
+	}
+	readline.cursorTo(process.stdout, 0);
+	readline.clearLine(process.stdout, 0);
+	process.stderr.write(text);
+	const rl = repl.rl;
+	if (typeof rl._refreshLine === "function") rl._refreshLine();
+	else process.stdout.write(cyan("executa> "));
+}
+
+//#endregion
+export { runExecutaDev };

package/dist/executa-init-COEmKDOE.js

@@ -0,0 +1,68 @@
+import { printMascot } from "./mascot-wlYTJqMs.js";
+import { dirname, join, resolve } from "node:path";
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import kleur from "kleur";
+
+//#region src/commands/executa-init.ts
+const here = dirname(fileURLToPath(import.meta.url));
+function templateRoot(template) {
+	for (const cand of [resolve(here, "..", "..", "templates", "executa", template), resolve(here, "..", "templates", "executa", template)]) if (existsSync(cand)) return cand;
+	throw new Error(`executa template not found: ${template}`);
+}
+function substitute(content, slug, toolId) {
+	const slugPy = slug.replace(/-/g, "_");
+	return content.replace(/__SLUG_PY__/g, slugPy).replace(/__SLUG__/g, slug).replace(/__TOOL_ID__/g, toolId);
+}
+function copyDirWithSubst(src, dst, slug, toolId) {
+	mkdirSync(dst, { recursive: true });
+	for (const entry of readdirSync(src, { withFileTypes: true })) {
+		const s = join(src, entry.name);
+		const d = join(dst, substitute(entry.name, slug, toolId));
+		if (entry.isDirectory()) copyDirWithSubst(s, d, slug, toolId);
+		else if (entry.isFile()) {
+			const stat = statSync(s);
+			if (stat.size < 256 * 1024) {
+				const buf = readFileSync(s);
+				if (!buf.includes(0)) {
+					writeFileSync(d, substitute(buf.toString("utf-8"), slug, toolId), "utf-8");
+					continue;
+				}
+			}
+			cpSync(s, d);
+		}
+	}
+}
+function runExecutaInit(opts) {
+	const target = resolve(process.cwd(), opts.targetDir);
+	if (existsSync(target) && !opts.force) {
+		if (readdirSync(target).filter((n) => !n.startsWith(".")).length > 0) {
+			console.error(kleur.red(`✗ target dir not empty: ${target} (use --force to override)`));
+			return 1;
+		}
+	}
+	if (!/^[a-z][a-z0-9-]{1,40}$/.test(opts.slug)) {
+		console.error(kleur.red(`✗ invalid slug "${opts.slug}": must match /^[a-z][a-z0-9-]{1,40}$/`));
+		return 1;
+	}
+	const toolId = opts.toolId ?? `tool-dev-${opts.slug}`;
+	if (!/^[a-z][a-z0-9-]{1,80}$/.test(toolId)) {
+		console.error(kleur.red(`✗ invalid tool_id "${toolId}": must match /^[a-z][a-z0-9-]{1,80}$/`));
+		return 1;
+	}
+	let tplRoot;
+	try {
+		tplRoot = templateRoot(opts.template);
+	} catch (e) {
+		console.error(kleur.red(`✗ ${e.message}`));
+		return 1;
+	}
+	copyDirWithSubst(tplRoot, target, opts.slug, toolId);
+	printMascot(`scaffolded an executa — happy hacking!`);
+	console.log(kleur.green(`✓ scaffolded "${opts.slug}" (${opts.template}) at ${target}`));
+	console.log(kleur.gray(`  next: cd ${opts.targetDir} && anna-app executa dev --describe`));
+	return 0;
+}
+
+//#endregion
+export { runExecutaInit };

package/dist/executa-register-66WKIwQQ.js

@@ -0,0 +1,47 @@
+import { getAccount } from "./credentials-BTv2IfUZ.js";
+import { bold, cyan, dim, green, red } from "kleur/colors";
+
+//#region src/commands/executa-register.ts
+async function runExecutaRegister(opts) {
+	const acc = getAccount(opts.account);
+	if (!acc) {
+		console.error(red("✗ no PAT on disk — run `anna-app login --host <nexus-url>` first."));
+		return 2;
+	}
+	const body = {
+		pat: acc.pat,
+		tool_id: opts.toolId,
+		slug: opts.slug,
+		name: opts.name
+	};
+	const url = `${acc.host.replace(/\/$/, "")}/api/v1/anna-apps/dev/executas/register`;
+	let res;
+	try {
+		res = await fetch(url, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify(body)
+		});
+	} catch (e) {
+		console.error(red(`✗ network error: ${e.message}`));
+		return 2;
+	}
+	if (res.status === 404) {
+		console.error(red("✗ your nexus does not expose POST /api/v1/anna-apps/dev/executas/register — upgrade matrix-nexus to a version that ships this endpoint."));
+		return 2;
+	}
+	if (!res.ok) {
+		const text = await res.text().catch(() => "");
+		console.error(red(`✗ HTTP ${res.status}: ${text}`));
+		return 1;
+	}
+	const out = await res.json();
+	console.log(`${green(out.created ? "✓ registered" : "✓ exists")} ${bold(out.slug)} ${dim(`(app_id=${out.app_id}, kind=${out.kind})`)}`);
+	console.log(`  tool_id   ${dim(out.tool_id)}`);
+	console.log(`  name      ${dim(out.name)}`);
+	console.log(`  host      ${cyan(acc.host)}`);
+	return 0;
+}
+
+//#endregion
+export { runExecutaRegister };

package/dist/mascot-wlYTJqMs.js

@@ -0,0 +1,218 @@
+import kleur from "kleur";
+
+//#region src/mascot.ts
+const FACE = [
+	255,
+	227,
+	234
+];
+const EYE = [
+	122,
+	90,
+	101
+];
+const GEO = (() => {
+	const VX0 = 252, VY0 = 280, VW = 520;
+	const n = (x, y) => [(x - VX0) / VW, (y - VY0) / VW];
+	const r = (v) => v / VW;
+	const [fcx, fcy] = n(512, 540);
+	const [lex, ley] = n(462, 520);
+	const [rex, rey] = n(562, 520);
+	return {
+		face: {
+			cx: fcx,
+			cy: fcy,
+			r: r(260)
+		},
+		eyeL: {
+			cx: lex,
+			cy: ley,
+			r: r(34)
+		},
+		eyeR: {
+			cx: rex,
+			cy: rey,
+			r: r(34)
+		}
+	};
+})();
+/** Sample the SVG at normalized (x, y) ∈ [0, 1]². Returns null for empty. */
+function sampleSvg(x, y) {
+	const inCircle = (cx, cy, r) => {
+		const dx = x - cx, dy = y - cy;
+		return dx * dx + dy * dy <= r * r;
+	};
+	let c = null;
+	if (inCircle(GEO.face.cx, GEO.face.cy, GEO.face.r)) c = FACE;
+	return c;
+}
+/**
+* 2×2 supersampled pixel using **majority vote** (not averaging).
+* Anti-aliases silhouette edges (filled vs empty) while keeping every
+* pixel a pure palette color — no muddy blends between the pink face and
+* the dark eyes. Ties resolve in favor of the topmost layer encountered.
+*/
+function pixel(px, py, w, h) {
+	const counts = new Map();
+	let nulls = 0;
+	for (const oy of [.25, .75]) for (const ox of [.25, .75]) {
+		const s = sampleSvg((px + ox) / w, (py + oy) / h);
+		if (!s) {
+			nulls++;
+			continue;
+		}
+		const key = `${s[0]},${s[1]},${s[2]}`;
+		const entry = counts.get(key);
+		if (entry) entry.n++;
+		else counts.set(key, {
+			color: s,
+			n: 1
+		});
+	}
+	if (counts.size === 0) return null;
+	let best = null;
+	for (const e of counts.values()) if (!best || e.n > best.n) best = e;
+	if (nulls > (best?.n ?? 0)) return null;
+	return best.color;
+}
+const FG = (c) => `\x1b[38;2;${c[0]};${c[1]};${c[2]}m`;
+const BG = (c) => `\x1b[48;2;${c[0]};${c[1]};${c[2]}m`;
+const BG_DEFAULT = "\x1B[49m";
+const RESET = "\x1B[0m";
+function eq(a, b) {
+	if (a === b) return true;
+	if (!a || !b) return false;
+	return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+}
+/**
+* Rasterize the face into a list of half-block lines.
+* `cols` is character width; pixel rows are derived from the cell aspect
+* so each pixel covers an (approximately) square area on screen.
+*/
+function renderFace(cols, cellAspect) {
+	const W = cols;
+	const charRows = Math.max(1, Math.round(cols / cellAspect));
+	const H = charRows * 2;
+	const eyeRow = Math.round(GEO.eyeL.cy * charRows - .5);
+	const eyeColL = Math.max(0, Math.round(GEO.eyeL.cx * W) - 1);
+	const eyeColR = Math.max(0, Math.round(GEO.eyeR.cx * W) - 1);
+	const isEyeCell = (cx, cy) => cy === eyeRow && (cx >= eyeColL && cx < eyeColL + 2 || cx >= eyeColR && cx < eyeColR + 2);
+	const rows = [];
+	for (let cy = 0; cy < charRows; cy++) {
+		let line = "";
+		let lastFg = null;
+		let lastBg = null;
+		let lastBgDefault = true;
+		for (let cx = 0; cx < W; cx++) {
+			if (isEyeCell(cx, cy)) {
+				if (!eq(lastFg, EYE)) {
+					line += FG(EYE);
+					lastFg = EYE;
+				}
+				if (lastBgDefault || !eq(lastBg, FACE)) {
+					line += BG(FACE);
+					lastBg = FACE;
+					lastBgDefault = false;
+				}
+				line += "█";
+				continue;
+			}
+			const top = pixel(cx, cy * 2, W, H);
+			const bot = pixel(cx, cy * 2 + 1, W, H);
+			if (!top && !bot) {
+				if (!lastBgDefault) {
+					line += BG_DEFAULT;
+					lastBgDefault = true;
+					lastBg = null;
+				}
+				line += " ";
+				continue;
+			}
+			if (top && bot) {
+				if (!eq(lastFg, top)) {
+					line += FG(top);
+					lastFg = top;
+				}
+				if (lastBgDefault || !eq(lastBg, bot)) {
+					line += BG(bot);
+					lastBg = bot;
+					lastBgDefault = false;
+				}
+				line += "▀";
+			} else if (top) {
+				if (!eq(lastFg, top)) {
+					line += FG(top);
+					lastFg = top;
+				}
+				if (!lastBgDefault) {
+					line += BG_DEFAULT;
+					lastBgDefault = true;
+					lastBg = null;
+				}
+				line += "▀";
+			} else {
+				if (!eq(lastFg, bot)) {
+					line += FG(bot);
+					lastFg = bot;
+				}
+				if (!lastBgDefault) {
+					line += BG_DEFAULT;
+					lastBgDefault = true;
+					lastBg = null;
+				}
+				line += "▄";
+			}
+		}
+		rows.push(line + RESET);
+	}
+	return rows;
+}
+function mascotEnabled() {
+	if (process.env.ANNA_CLI_NO_MASCOT) return false;
+	if (process.env.NO_COLOR) return false;
+	if (process.env.ANNA_CLI_FORCE_MASCOT) return true;
+	return Boolean(process.stdout.isTTY);
+}
+function pickWidth() {
+	const override = Number.parseInt(process.env.ANNA_CLI_MASCOT_WIDTH ?? "", 10);
+	if (Number.isFinite(override) && override >= 10 && override <= 120) return override;
+	const cols = process.stdout.columns || 80;
+	if (cols < 60) return 10;
+	if (cols >= 120) return 16;
+	return 13;
+}
+function pickAspect() {
+	const v = Number.parseFloat(process.env.ANNA_CLI_MASCOT_ASPECT ?? "");
+	if (Number.isFinite(v) && v >= 1.2 && v <= 3) return v;
+	return 2.1;
+}
+/**
+* Render the mascot as a multi-line string. Always returns the colored art
+* (callers decide whether to print based on `mascotEnabled`).
+*/
+function renderMascot(message) {
+	const cols = pickWidth();
+	const aspect = pickAspect();
+	const face = renderFace(cols, aspect);
+	const pad = " ".repeat(2);
+	const label = kleur.magenta().bold("Anna");
+	const tagline = kleur.gray("Anna App developer CLI");
+	const textLines = [`${label}  ${tagline}`];
+	if (message) textLines.push(`${kleur.gray("›")} ${message}`);
+	const start = Math.max(0, Math.floor((face.length - textLines.length) / 2));
+	const lines = [];
+	for (let i = 0; i < face.length; i++) {
+		const tIdx = i - start;
+		const text = tIdx >= 0 && tIdx < textLines.length ? "  " + textLines[tIdx] : "";
+		lines.push(pad + face[i] + text);
+	}
+	return lines.join("\n");
+}
+/** Print the mascot to stderr if enabled. Stderr keeps stdout clean for piping. */
+function printMascot(message) {
+	if (!mascotEnabled()) return;
+	process.stderr.write(renderMascot(message) + "\n\n");
+}
+
+//#endregion
+export { printMascot };