ndomo 0.1.0

package/skills/zig-0.16/scripts/check-zig-version.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+# Verify Zig 0.16.x is available
+set -e
+
+ZIG_CMD="${ZIG_CMD:-zig}"
+
+if ! command -v "$ZIG_CMD" &> /dev/null; then
+    echo "ERROR: zig not found. Set ZIG_CMD or add zig to PATH."
+    exit 1
+fi
+
+VERSION=$("$ZIG_CMD" version)
+MAJOR=$(echo "$VERSION" | cut -d. -f1)
+MINOR=$(echo "$VERSION" | cut -d. -f2)
+
+if [[ "$MAJOR" -eq 0 && "$MINOR" -ge 16 ]] || [[ "$MAJOR" -ge 1 ]]; then
+    echo "OK: Zig $VERSION detected."
+else
+    echo "WARNING: Zig $VERSION detected, this skill is for 0.16+."
+    exit 1
+fi

package/src/cli/analyses.ts

@@ -0,0 +1,280 @@
+#!/usr/bin/env bun
+/**
+ * ndomo analyses CLI — list, get, search, archive analyses.
+ *
+ * Reads .ndomo/state.db from the project root (resolved same as status.ts).
+ * Supports list/get/search/archive subcommands with filters.
+ *
+ * Uses bun:sqlite (synchronous) — no async/await on DB ops.
+ */
+
+import { Database } from "bun:sqlite";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import {
+  archiveAnalysis,
+  getAnalysis,
+  getAnalysisBySlug,
+  listAnalyses,
+  searchAnalyses,
+} from "../db/analyses.ts";
+import { runMigrations } from "../db/migrations.ts";
+import type { Analysis } from "../db/types.ts";
+
+const NDOMO_DIR = ".ndomo";
+const DB_FILE = "state.db";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+/** Resolve DB path — same logic as src/cli/status.ts. */
+function resolveDbPath(): string | null {
+  const cwdPath = join(process.cwd(), NDOMO_DIR, DB_FILE);
+  if (existsSync(cwdPath)) return cwdPath;
+
+  let dir = process.cwd();
+  for (let i = 0; i < 5; i++) {
+    const parent = join(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+    const candidate = join(dir, NDOMO_DIR, DB_FILE);
+    if (existsSync(candidate)) return candidate;
+  }
+
+  return null;
+}
+
+/** Short ID — first 8 chars. */
+function shortId(id: string): string {
+  return id.slice(0, 8);
+}
+
+/** Truncate string to maxLen with "..." suffix. */
+function truncate(s: string, maxLen: number): string {
+  if (s.length <= maxLen) return s;
+  return `${s.slice(0, maxLen - 3)}...`;
+}
+
+/** Print analyses as table. */
+function printTable(analyses: Analysis[]): void {
+  if (analyses.length === 0) {
+    console.log("no analyses found");
+    return;
+  }
+
+  console.log(
+    `  ${"id".padEnd(10)}${"slug".padEnd(26)}${"title".padEnd(32)}${"agent".padEnd(12)}${"sourcePlan".padEnd(12)}${"updatedAt".padEnd(22)}`,
+  );
+
+  for (const a of analyses) {
+    const id = shortId(a.id);
+    const slug = truncate(a.slug, 24);
+    const title = truncate(a.title, 30);
+    const agent = truncate(a.agent, 10);
+    const sourcePlan = a.sourcePlanId ? shortId(a.sourcePlanId) : "-";
+    const updatedAt = a.updatedAt ?? "-";
+
+    console.log(
+      `  ${id.padEnd(10)}${slug.padEnd(26)}${title.padEnd(32)}${agent.padEnd(12)}${sourcePlan.padEnd(12)}${updatedAt.padEnd(22)}`,
+    );
+  }
+}
+
+/** Print single analysis as JSON. */
+function printJson(data: unknown): void {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+/** Print help text. */
+function printHelp(): void {
+  console.log(`Usage: ndomo analyses <subcommand> [options]
+
+Subcommands:
+  list                   List analyses (default)
+    --agent <name>       Filter by agent
+    --source-plan <id>   Filter by source plan ID
+    --project <path>     Filter by project path
+    --archived           Include archived analyses
+    --limit <n>          Max results (default 50)
+
+  get <id-or-slug>       Get analysis by ID or slug
+    --project <path>     Required when using slug
+
+  search <query>         Full-text search over title+summary+findings
+    --limit <n>          Max results (default 20)
+
+  archive <id>           Soft-delete an analysis
+
+  help                   Show this help`);
+}
+
+// ─── Subcommand handlers ─────────────────────────────────────────────────────
+
+function handleList(db: Database, args: string[]): void {
+  let agent: string | undefined;
+  let sourcePlanId: string | undefined;
+  let projectPath: string | undefined;
+  let archived: boolean | undefined;
+  let limit: number | undefined;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]!;
+    if (arg === "--agent" && i + 1 < args.length) {
+      agent = args[++i]!;
+    } else if (arg === "--source-plan" && i + 1 < args.length) {
+      sourcePlanId = args[++i]!;
+    } else if (arg === "--project" && i + 1 < args.length) {
+      projectPath = args[++i]!;
+    } else if (arg === "--archived") {
+      archived = true;
+    } else if (arg === "--limit" && i + 1 < args.length) {
+      const n = Number.parseInt(args[++i]!, 10);
+      if (Number.isNaN(n) || n < 1) {
+        console.error("error: --limit must be a positive integer");
+        process.exit(1);
+      }
+      limit = n;
+    }
+  }
+
+  const filters: Parameters<typeof listAnalyses>[1] = {};
+  if (agent !== undefined) filters.agent = agent;
+  if (sourcePlanId !== undefined) filters.sourcePlanId = sourcePlanId;
+  if (projectPath !== undefined) filters.projectPath = projectPath;
+  if (archived !== undefined) filters.archived = archived;
+  if (limit !== undefined) filters.limit = limit;
+
+  const results = listAnalyses(db, filters);
+  printTable(results);
+}
+
+function handleGet(db: Database, args: string[]): void {
+  if (args.length === 0) {
+    console.error("error: get requires an ID or slug argument");
+    process.exit(1);
+  }
+
+  const identifier = args[0]!;
+  let projectPath: string | undefined;
+
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === "--project" && i + 1 < args.length) {
+      projectPath = args[++i]!;
+    }
+  }
+
+  let analysis: Analysis | null = null;
+
+  // UUIDs have 8-4-4-4-12 format; slugs are shorter kebab-case
+  const isUuid = identifier.includes("-") && identifier.length >= 36;
+
+  if (isUuid) {
+    analysis = getAnalysis(db, identifier);
+  } else {
+    // Treat as slug — requires --project
+    if (projectPath === undefined) {
+      console.error("error: --project <path> is required when using slug");
+      process.exit(1);
+    }
+    analysis = getAnalysisBySlug(db, identifier, projectPath);
+  }
+
+  if (!analysis) {
+    console.error(`error: analysis '${identifier}' not found`);
+    process.exit(1);
+  }
+
+  printJson(analysis);
+}
+
+function handleSearch(db: Database, args: string[]): void {
+  if (args.length === 0) {
+    console.error("error: search requires a query argument");
+    process.exit(1);
+  }
+
+  const query = args[0]!;
+  let limit = 20;
+
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === "--limit" && i + 1 < args.length) {
+      const n = Number.parseInt(args[++i]!, 10);
+      if (Number.isNaN(n) || n < 1) {
+        console.error("error: --limit must be a positive integer");
+        process.exit(1);
+      }
+      limit = n;
+    }
+  }
+
+  const results = searchAnalyses(db, query, { limit });
+  printTable(results);
+}
+
+function handleArchive(db: Database, args: string[]): void {
+  if (args.length === 0) {
+    console.error("error: archive requires an ID argument");
+    process.exit(1);
+  }
+
+  const id = args[0]!;
+  try {
+    const archived = archiveAnalysis(db, id);
+    console.log(`archived analysis: ${shortId(archived.id)} (${archived.slug})`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`error: ${message}`);
+    process.exit(1);
+  }
+}
+
+// ─── Main ────────────────────────────────────────────────────────────────────
+
+export function runAnalyses(args: string[]): void {
+  const subcommand = args[0];
+
+  // Help (before DB resolution)
+  if (!subcommand || subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+    printHelp();
+    return;
+  }
+
+  const dbPath = resolveDbPath();
+  if (!dbPath) {
+    console.error("error: .ndomo/state.db not found — run from project root or parent dir");
+    process.exit(1);
+  }
+
+  const db = new Database(dbPath);
+  db.exec("PRAGMA foreign_keys = ON");
+  runMigrations(db);
+
+  try {
+    const rest = args.slice(1);
+
+    switch (subcommand) {
+      case "list":
+        handleList(db, rest);
+        break;
+      case "get":
+        handleGet(db, rest);
+        break;
+      case "search":
+        handleSearch(db, rest);
+        break;
+      case "archive":
+        handleArchive(db, rest);
+        break;
+      default:
+        console.error(`error: unknown subcommand '${subcommand}'`);
+        printHelp();
+        process.exit(1);
+    }
+  } finally {
+    db.close();
+  }
+}
+
+// Direct execution
+if (import.meta.main) {
+  runAnalyses(process.argv.slice(2));
+}

package/src/cli/index.ts

@@ -0,0 +1,108 @@
+#!/usr/bin/env bun
+/**
+ * ndomo CLI — unified entry point for all subcommands.
+ *
+ * Usage:
+ *   bun run src/cli/index.ts <command> [options]
+ *
+ * Commands:
+ *   status    Show plans grouped by status with task counts
+ *   serve     Start the HTTP server
+ *   vacuum    Reclaim disk space from .ndomo/state.db
+ *   smoke     Run smoke tests
+ *   help      Show this help
+ *
+ * Each subcommand can also be run directly:
+ *   bun run src/cli/status.ts --plans
+ *   bun run src/cli/serve.ts --port 8080
+ */
+
+const COMMANDS: Record<
+  string,
+  { description: string; run: (args: string[]) => void | Promise<void> }
+> = {
+  status: {
+    description: "Show plans grouped by status with task counts",
+    run: async (args) => {
+      const { runStatus } = await import("./status.ts");
+      runStatus(args);
+    },
+  },
+  serve: {
+    description: "Start the HTTP server",
+    run: async (args) => {
+      const { runServe } = await import("./serve.ts");
+      await runServe(args);
+    },
+  },
+  vacuum: {
+    description: "Reclaim disk space from .ndomo/state.db",
+    run: async (args) => {
+      const { vacuumProject } = await import("./vacuum.ts");
+      const projectDir = args[0] ?? process.cwd();
+      const result = vacuumProject(projectDir);
+      const delta = result.sizeBefore - result.sizeAfter;
+      console.log(`[vacuum] incremental_vacuum: reclaimed ${result.pagesReclaimed} pages`);
+      console.log(`[vacuum] wal_checkpoint(TRUNCATE): ${JSON.stringify(result.checkpoint)}`);
+      console.log(
+        `[vacuum] file size: ${result.sizeBefore} → ${result.sizeAfter} bytes (${delta >= 0 ? "-" : "+"}${Math.abs(delta)} bytes)`,
+      );
+    },
+  },
+  smoke: {
+    description: "Run smoke tests",
+    run: async () => {
+      // smoke.ts runs on import — just import it
+      await import("./smoke.ts");
+    },
+  },
+};
+
+function printHelp(): void {
+  console.log(`ndomo CLI — multi-agent plugin
+
+Usage:
+  bun run src/cli/index.ts <command> [options]
+
+Commands:`);
+
+  for (const [name, cmd] of Object.entries(COMMANDS)) {
+    console.log(`  ${name.padEnd(12)}${cmd.description}`);
+  }
+
+  console.log(`
+Each subcommand can also be run directly:
+  bun run src/cli/status.ts --plans
+  bun run src/cli/serve.ts --port 8080
+  bun run src/cli/vacuum.ts`);
+}
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+  const commandName = args[0];
+
+  if (!commandName || commandName === "--help" || commandName === "-h" || commandName === "help") {
+    printHelp();
+    process.exit(commandName ? 0 : 1);
+  }
+
+  const command = COMMANDS[commandName];
+  if (!command) {
+    console.error(
+      `error: unknown command "${commandName}". Run "ndomo help" for available commands.`,
+    );
+    process.exit(1);
+  }
+
+  try {
+    await command.run(args.slice(1));
+  } catch (err) {
+    console.error(`error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+
+// Direct execution
+if (import.meta.main) {
+  await main();
+}

package/src/cli/serve.ts

@@ -0,0 +1,192 @@
+#!/usr/bin/env bun
+/**
+ * ndomo serve — start the HTTP server.
+ *
+ * Usage:
+ *   bun run src/cli/serve.ts [options]
+ *
+ * Options:
+ *   --port <n>       Port number (default: from config, 4097)
+ *   --no-auth        Disable HTTP basic auth requirement
+ *   --cors <origins> Comma-separated allowed origins (default: from config, "*")
+ *   --force          Start even when NDOMO_HTTP_ENABLED is not "true"
+ *
+ * Examples:
+ *   bun run src/cli/serve.ts
+ *   bun run src/cli/serve.ts --port 8080 --no-auth
+ *   bun run src/cli/serve.ts --cors "https://app.example.com,https://admin.example.com"
+ *   bun run src/cli/serve.ts --force --port 4098
+ *
+ * Graceful shutdown on SIGINT/SIGTERM.
+ * Exit codes: 0 = clean shutdown, 1 = startup failure.
+ */
+
+import { Database } from "bun:sqlite";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import type { HttpConfig } from "../config/schema.ts";
+import { loadHttpConfig } from "../config/schema.ts";
+import { runMigrations } from "../db/migrations.ts";
+import { type HttpServerHandle, startHttpServer } from "../http/server.ts";
+
+const NDOMO_DIR = ".ndomo";
+const DB_FILE = "state.db";
+
+/** Resolve DB path — same logic as src/db/client.ts. */
+function resolveDbPath(): string | null {
+  const cwdPath = join(process.cwd(), NDOMO_DIR, DB_FILE);
+  if (existsSync(cwdPath)) return cwdPath;
+
+  let dir = process.cwd();
+  for (let i = 0; i < 5; i++) {
+    const parent = join(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+    const candidate = join(dir, NDOMO_DIR, DB_FILE);
+    if (existsSync(candidate)) return candidate;
+  }
+
+  return null;
+}
+
+/** Parse CLI args into a partial config override. */
+function parseArgs(args: string[]): {
+  port?: number;
+  authRequired?: boolean;
+  corsOrigins?: string[];
+  force: boolean;
+} {
+  const result: { port?: number; authRequired?: boolean; corsOrigins?: string[]; force: boolean } =
+    {
+      force: false,
+    };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--port" && i + 1 < args.length) {
+      const portStr = args[++i];
+      if (!portStr) {
+        console.error("error: --port requires a value");
+        process.exit(1);
+      }
+      const port = Number(portStr);
+      if (Number.isNaN(port) || port < 1 || port > 65535) {
+        console.error(`error: invalid port "${portStr}". Must be 1-65535.`);
+        process.exit(1);
+      }
+      result.port = port;
+    } else if (arg === "--no-auth") {
+      result.authRequired = false;
+    } else if (arg === "--cors" && i + 1 < args.length) {
+      const corsStr = args[++i];
+      if (!corsStr) {
+        console.error("error: --cors requires a value");
+        process.exit(1);
+      }
+      result.corsOrigins = corsStr.split(",").map((s) => s.trim());
+    } else if (arg === "--force") {
+      result.force = true;
+    } else if (arg === "--help" || arg === "-h") {
+      console.log(`ndomo serve — start the HTTP server
+
+Options:
+  --port <n>       Port number (default: from config, 4097)
+  --no-auth        Disable HTTP basic auth requirement
+  --cors <origins> Comma-separated allowed origins (default: from config, "*")
+  --force          Start even when NDOMO_HTTP_ENABLED is not "true"
+  --help, -h       Show this help`);
+      process.exit(0);
+    }
+  }
+
+  return result;
+}
+
+/** Print startup banner. */
+function printBanner(config: HttpConfig, dbPath: string): void {
+  console.log(`
+┌─────────────────────────────────────┐
+│  ndomo HTTP server                  │
+├─────────────────────────────────────┤
+│  port:    ${String(config.port).padEnd(25)}│
+│  auth:    ${(config.auth.required ? "enabled" : "disabled").padEnd(25)}│
+│  cors:    ${config.cors.origins.join(", ").padEnd(25).slice(0, 25)}│
+│  db:      ${dbPath.slice(-25).padEnd(25)}│
+│  pid:     ${String(process.pid).padEnd(25)}│
+└─────────────────────────────────────┘`);
+}
+
+/** Main entry point. */
+export async function runServe(args: string[]): Promise<void> {
+  const opts = parseArgs(args);
+
+  // Resolve DB
+  const dbPath = resolveDbPath();
+  if (!dbPath) {
+    console.error("error: .ndomo/state.db not found — run from project root or parent dir");
+    process.exit(1);
+  }
+
+  // Open DB
+  const db = new Database(dbPath);
+  db.exec("PRAGMA foreign_keys = ON");
+  runMigrations(db);
+
+  // Load config + apply CLI overrides
+  const config = loadHttpConfig();
+
+  if (opts.port !== undefined) config.port = opts.port;
+  if (opts.authRequired !== undefined) config.auth.required = opts.authRequired;
+  if (opts.corsOrigins !== undefined) config.cors.origins = opts.corsOrigins;
+
+  // Feature gate: require NDOMO_HTTP_ENABLED=true unless --force
+  if (!config.enabled && !opts.force) {
+    console.error(
+      "error: HTTP server is disabled (NDOMO_HTTP_ENABLED is not 'true'). Use --force to override.",
+    );
+    db.close();
+    process.exit(1);
+  }
+
+  printBanner(config, dbPath);
+
+  // Start server
+  let serverHandle: HttpServerHandle;
+  try {
+    serverHandle = await startHttpServer({ db, httpConfig: config });
+  } catch (err) {
+    console.error(
+      `error: failed to start HTTP server: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    db.close();
+    process.exit(1);
+  }
+
+  console.log(`✓ HTTP server listening on port ${serverHandle.port}`);
+
+  // Graceful shutdown
+  let shuttingDown = false;
+  const shutdown = async (signal: string) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    console.log(`\n${signal} received — shutting down...`);
+    try {
+      await serverHandle.stop();
+      db.close();
+      console.log("✓ Server stopped cleanly.");
+      process.exit(0);
+    } catch (err) {
+      console.error(`error during shutdown: ${err instanceof Error ? err.message : String(err)}`);
+      db.close();
+      process.exit(1);
+    }
+  };
+
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+}
+
+// Direct execution
+if (import.meta.main) {
+  runServe(process.argv.slice(2));
+}