cuekit 0.0.12

package/package.json

@@ -0,0 +1,53 @@
+{
+	"name": "cuekit",
+	"version": "0.0.12",
+	"description": "cuekit — delegation substrate for coding agents",
+	"type": "module",
+	"exports": {
+		".": "./src/index.ts"
+	},
+	"bin": {
+		"cuekit": "./bin/cuekit.js"
+	},
+	"files": [
+		"bin/",
+		"src/",
+		"README.md"
+	],
+	"scripts": {
+		"typecheck": "tsc --noEmit",
+		"test": "bun test"
+	},
+	"dependencies": {},
+	"engines": {
+		"bun": ">=1.2.0"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"keywords": [
+		"ai",
+		"agent",
+		"cli",
+		"mcp",
+		"coding-agent",
+		"orchestration"
+	],
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/takemo101/cuekit.git"
+	},
+	"homepage": "https://github.com/takemo101/cuekit#readme",
+	"bugs": {
+		"url": "https://github.com/takemo101/cuekit/issues"
+	},
+	"optionalDependencies": {
+		"@opentui/core-darwin-arm64": "0.2.1",
+		"@opentui/core-darwin-x64": "0.2.1",
+		"@opentui/core-linux-arm64": "0.2.1",
+		"@opentui/core-linux-x64": "0.2.1",
+		"@opentui/core-win32-arm64": "0.2.1",
+		"@opentui/core-win32-x64": "0.2.1"
+	}
+}

package/src/bin.ts

@@ -0,0 +1,158 @@
+#!/usr/bin/env bun
+import type { Database } from "bun:sqlite";
+import { existsSync, statSync } from "node:fs";
+import {
+	type AdapterRegistry,
+	buildAdapterRegistry,
+	buildMultiplexerBackend,
+	type MultiplexerBackend,
+} from "@cuekit/adapters";
+import { findProjectRoot } from "@cuekit/agent-profiles";
+import { createStderrLogger, parseLogLevel, silentLogger } from "@cuekit/core";
+import { createTuiContext, runCuekitMcpBin } from "@cuekit/mcp";
+import { loadProjectConfig } from "@cuekit/project-config";
+import { openDatabase, runMigrations } from "@cuekit/store";
+import {
+	classifyCuekitCommand,
+	printDoctorHelp,
+	printMainHelp,
+	printUpdateHelp,
+} from "./dispatch.ts";
+import { runDoctor } from "./doctor.ts";
+import {
+	printTuiHelp,
+	runInitCommand,
+	runJcodeMcpAddCommand,
+	runPiMcpAddCommand,
+} from "./human-commands.ts";
+import { runUpdate } from "./update.ts";
+
+function closeQuietly(db: Database): void {
+	try {
+		db.close();
+	} catch {
+		// ignore close errors on shutdown
+	}
+}
+
+// Re-export the canonical adapter-registry factory under a TUI-specific
+// name to preserve the existing call sites and regression-test imports.
+// The actual build-out lives in `@cuekit/adapters/build-registry` so it
+// can be shared between `cuekit --mcp` (the MCP server) and
+// `cuekit tui` (this binary). See #382 for the unification rationale.
+export const buildTuiAdapterRegistry: (
+	db: Database,
+	panes: MultiplexerBackend,
+	options?: { logger?: import("@cuekit/core").Logger },
+) => AdapterRegistry = buildAdapterRegistry;
+
+async function runTuiCommand(): Promise<void> {
+	const logLevel = parseLogLevel(process.env.CUEKIT_LOG_LEVEL);
+	const logger = createStderrLogger({ minLevel: logLevel });
+	const tuiLogger = silentLogger;
+	let db: Database | undefined;
+	try {
+		const dbPath = process.env.CUEKIT_DB_PATH;
+		const useCustomPath = dbPath !== undefined && dbPath.length > 0;
+		db = openDatabase(useCustomPath ? { path: dbPath } : {});
+		runMigrations(db);
+
+		const { runTuiLoop } = await import("@cuekit/tui");
+		const all = process.argv.includes("--all");
+		const pathScope = process.argv.includes("--path");
+		const projectRoot = findProjectRoot(process.cwd(), { existsSync, statSync });
+		const loadedConfig = all || pathScope ? undefined : loadProjectConfig(process.cwd());
+		if (loadedConfig && !loadedConfig.ok) {
+			throw new Error(loadedConfig.error);
+		}
+		const built = await buildMultiplexerBackend(
+			loadedConfig?.ok ? loadedConfig.config : undefined,
+			{ logger: tuiLogger },
+		);
+		const panes = built.backend;
+		const registry = buildTuiAdapterRegistry(db, panes, { logger: tuiLogger });
+		await runTuiLoop(
+			createTuiContext(
+				{ db, registry, panes },
+				{
+					all,
+					...(loadedConfig?.ok && loadedConfig.discovery.source === "config"
+						? loadedConfig.config.tui?.scope === "path"
+							? { projectRoot }
+							: {
+									projectScope: {
+										project_uid: loadedConfig.identity.project_uid,
+										project_root: loadedConfig.discovery.configRoot,
+									},
+								}
+						: { projectRoot }),
+				},
+			) as never,
+		);
+		closeQuietly(db);
+	} catch (err) {
+		if (db) closeQuietly(db);
+		logger.error("tui startup failed", {
+			reason: err instanceof Error ? err.message : String(err),
+		});
+		process.exit(1);
+	}
+}
+
+export async function runCuekitCliBin(): Promise<void> {
+	const argv = process.argv.slice(2);
+	const classification = classifyCuekitCommand(argv);
+	if (classification.kind === "help") {
+		process.stdout.write(printMainHelp());
+		return;
+	}
+	if (classification.kind === "init") {
+		const result = runInitCommand(argv.slice(1));
+		process.stdout.write(result.stdout);
+		if (result.stderr) process.stderr.write(result.stderr);
+		if (result.exitCode !== 0) process.exit(result.exitCode);
+		return;
+	}
+	if (classification.kind === "tui" && (argv.includes("--help") || argv.includes("-h"))) {
+		process.stdout.write(printTuiHelp());
+		return;
+	}
+	if (classification.kind === "tui") {
+		await runTuiCommand();
+		return;
+	}
+	if (classification.kind === "mcp-add") {
+		const jcodeResult = runJcodeMcpAddCommand(argv.slice(2));
+		const result = jcodeResult.shouldDelegate ? runPiMcpAddCommand(argv.slice(2)) : jcodeResult;
+		process.stdout.write(result.stdout);
+		if (result.stderr) process.stderr.write(result.stderr);
+		if (result.exitCode !== 0) process.exit(result.exitCode);
+		if (!result.shouldDelegate) return;
+		process.argv = [process.argv[0] ?? "bun", process.argv[1] ?? "cuekit", ...result.delegateArgv];
+	}
+	if (classification.kind === "doctor") {
+		if (argv.includes("--help") || argv.includes("-h")) {
+			process.stdout.write(printDoctorHelp());
+			return;
+		}
+		const result = await runDoctor({ fix: argv.includes("--fix") });
+		process.stdout.write(result.stdout);
+		if (result.stderr) process.stderr.write(result.stderr);
+		process.exit(result.exitCode);
+	}
+	if (classification.kind === "update") {
+		if (argv.includes("--help") || argv.includes("-h")) {
+			process.stdout.write(printUpdateHelp());
+			return;
+		}
+		const result = await runUpdate();
+		process.stdout.write(result.stdout);
+		if (result.stderr) process.stderr.write(result.stderr);
+		process.exit(result.exitCode);
+	}
+	await runCuekitMcpBin();
+}
+
+if (import.meta.main) {
+	await runCuekitCliBin();
+}

package/src/dispatch.ts

@@ -0,0 +1,93 @@
+export type CuekitCommandClassification =
+	| { kind: "help" }
+	| { kind: "doctor" }
+	| { kind: "update" }
+	| { kind: "init" }
+	| { kind: "tui" }
+	| { kind: "mcp-config" }
+	| { kind: "mcp-add" }
+	| { kind: "delegate" };
+
+export function classifyCuekitCommand(argv: string[]): CuekitCommandClassification {
+	const command = argv[0];
+	if (command === undefined || command === "--help" || command === "-h") {
+		return { kind: "help" };
+	}
+	if (command === "init") {
+		return { kind: "init" };
+	}
+	if (command === "tui") {
+		return { kind: "tui" };
+	}
+	if (command === "mcp" && argv[1] === "config") {
+		return { kind: "mcp-config" };
+	}
+	if (command === "mcp" && argv[1] === "add") {
+		return { kind: "mcp-add" };
+	}
+	if (command === "doctor") {
+		return { kind: "doctor" };
+	}
+	if (command === "update") {
+		return { kind: "update" };
+	}
+	return { kind: "delegate" };
+}
+
+export function printMainHelp(): string {
+	return [
+		"cuekit — delegation substrate for coding agents",
+		"",
+		"Usage: cuekit <command> [options]",
+		"",
+		"Human-only commands:",
+		"  cuekit init    Create .cuekit.yaml and update .gitignore",
+		"  cuekit tui     Open the interactive task cockpit",
+		"  cuekit doctor  Diagnose local cuekit setup",
+		"  cuekit update  Show the latest Bun/GitHub install command",
+		"",
+		"Command groups:",
+		"  task, team, adapter, agent, session, tool, mcp",
+		"",
+		"Use 'cuekit init --help' or 'cuekit tui --help' for human-only command help.",
+		"",
+	].join("\n");
+}
+
+export function printDoctorHelp(): string {
+	return [
+		"cuekit doctor — diagnose local cuekit setup",
+		"",
+		"Usage: cuekit doctor [options]",
+		"",
+		"Options:",
+		"  -h, --help  Show this help message",
+		"  --fix       Repair safe state DB issues such as SQLite-formatted task timestamps",
+		"",
+		"Checks:",
+		"  cuekit version, bun, tmux, state db, project config, MCP config helper, update",
+		"",
+		"Exit codes:",
+		"  0  All required checks pass (warnings are non-blocking)",
+		"  1  One or more required checks failed",
+		"",
+	].join("\n");
+}
+
+export function printUpdateHelp(): string {
+	return [
+		"cuekit update — check for a newer cuekit release",
+		"",
+		"Usage: cuekit update [options]",
+		"",
+		"Options:",
+		"  -h, --help  Show this help message",
+		"",
+		"Prints the current installed version and the latest stable release tag from",
+		"GitHub, then shows the exact bun command to upgrade.",
+		"",
+		"Update is advisory only: it never runs bun install automatically.",
+		"After upgrading, restart any MCP client that uses cuekit.",
+		"",
+	].join("\n");
+}