@creativeintelligence/abbie 0.1.0

package/package.json

@@ -0,0 +1,101 @@
+{
+  "name": "@creativeintelligence/abbie",
+  "version": "0.1.0",
+  "type": "module",
+  "license": "MIT",
+  "description": "Abbie — agent orchestration CLI",
+  "sideEffects": false,
+  "main": "./dist/lib.js",
+  "exports": {
+    ".": {
+      "types": "./dist/lib.d.ts",
+      "import": "./dist/lib.js"
+    },
+    "./commands/*": {
+      "types": "./dist/cli/commands/*.d.ts",
+      "import": "./dist/cli/commands/*.js"
+    }
+  },
+  "types": "./dist/lib.d.ts",
+  "bin": {
+    "abbie": "./bin/run.js",
+    "abbie-cli": "./bin/run.js"
+  },
+  "files": [
+    "/bin",
+    "/src",
+    "/dist",
+    "/scripts",
+    "/extensions",
+    "/oclif.manifest.json"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "oclif": {
+    "bin": "abbie",
+    "dirname": "abbie",
+    "plugins": [
+      "@oclif/plugin-help",
+      "@oclif/plugin-not-found"
+    ],
+    "additionalHelpFlags": [
+      "-h"
+    ],
+    "topicSeparator": " ",
+    "description": "Agent orchestration CLI",
+    "commands": "./dist/cli/commands",
+    "topics": {
+      "session": {
+        "description": "Manage agent sessions"
+      },
+      "windows": {
+        "description": "Workspace windows inventory"
+      },
+      "report": {
+        "description": "Lifecycle reporting"
+      },
+      "auto": {
+        "description": "Auto-discover and spawn agents"
+      },
+      "plan": {
+        "description": "Planning sessions"
+      },
+      "hooks": {
+        "description": "Agent platform hooks"
+      },
+      "reference": {
+        "description": "Design reference bank"
+      }
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "postbuild": "bun run ./scripts/generate-manifest.ts",
+    "dev": "tsc --watch",
+    "manifest": "bun run ./scripts/generate-manifest.ts",
+    "test": "vitest run --passWithNoTests && bun test src tests",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src/cli src/lib src/lib.ts",
+    "cli": "bun run ./bin/dev.js"
+  },
+  "dependencies": {
+    "@abbie/backend": "workspace:*",
+    "@abbie/sdk": "workspace:*",
+    "@oclif/core": "^4",
+    "@oclif/plugin-help": "^6",
+    "@oclif/plugin-not-found": "^3",
+    "@lnittman/convex-encryption": "^0.1.0",
+    "@lnittman/icons": "^0.3.0",
+    "convex": "^1.31.6",
+    "tar-fs": "^3"
+  },
+  "devDependencies": {
+    "@lnittman/config": "^0.1.1",
+    "@types/bun": "^1",
+    "@types/tar-fs": "^2",
+    "typescript": "^5",
+    "vitest": "^4.0.18"
+  }
+}

package/scripts/generate-manifest.ts

@@ -0,0 +1,44 @@
+import { Plugin } from "@oclif/core";
+import { readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+const root = resolve(import.meta.dir, "..");
+const manifestPath = join(root, "oclif.manifest.json");
+const pjsonPath = join(root, "package.json");
+
+const pjson = JSON.parse(readFileSync(pjsonPath, "utf8")) as Record<string, unknown>;
+
+const plugin = new Plugin({
+  root,
+  // oclif expects the parsed package.json to build a manifest. Keep this local
+  // so generation doesn't depend on other workspace tooling.
+  pjson,
+  isRoot: true,
+  ignoreManifest: true,
+});
+
+await plugin.load();
+
+function sortJson(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map(sortJson);
+  }
+
+  if (value && typeof value === "object") {
+    const record = value as Record<string, unknown>;
+    const out: Record<string, unknown> = {};
+    for (const key of Object.keys(record).sort()) {
+      out[key] = sortJson(record[key]);
+    }
+    return out;
+  }
+
+  return value;
+}
+
+const manifest = sortJson(plugin.manifest);
+writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+// eslint-disable-next-line no-console
+console.log(
+  `Wrote ${manifestPath} (${Object.keys(plugin.manifest.commands).length} commands)`,
+);

package/src/cli/base-command.ts

@@ -0,0 +1,233 @@
+import { join } from "node:path";
+import { Command, Flags } from "@oclif/core";
+import { initAnalytics, registerShutdown, telemetry } from "../lib/analytics.js";
+import { errorToExitCode, toJsonError } from "../lib/errors.js";
+
+// Register shutdown handler once at module load
+let shutdownRegistered = false;
+
+type ParsedFlags = {
+  format?: string;
+  quiet?: boolean;
+  "json-errors"?: boolean;
+  ndjson?: boolean;
+  json?: boolean;
+};
+
+/**
+ * Shared base command for abbie CLI.
+ *
+ * Commands should extend BaseCommand and implement `protected execute()`
+ * instead of overriding `run()`. The public `run()` method delegates to
+ * `execute()` and must not be overridden by subclasses.
+ */
+export abstract class BaseCommand extends Command {
+  static hidden = true;
+  static enableJsonFlag = true;
+
+  static baseFlags = {
+    format: Flags.string({
+      description: "Output format",
+      options: ["text", "json", "yaml"],
+    }),
+    quiet: Flags.boolean({
+      char: "q",
+      description: "Suppress info messages",
+      default: false,
+    }),
+    "json-errors": Flags.boolean({
+      description: "Output errors as JSON",
+      default: false,
+    }),
+    ndjson: Flags.boolean({
+      description: "Output newline-delimited JSON (one object per line)",
+      default: false,
+    }),
+  };
+
+  /** Parsed flags available to subclasses and utility methods */
+  protected parsedFlags?: ParsedFlags & Record<string, unknown>;
+
+  /** Subclasses implement their logic here instead of overriding `run()`. */
+  protected abstract execute(): Promise<unknown>;
+
+  /** Final run implementation – do not override in subclasses. */
+  public async run(): Promise<unknown> {
+    // Register shutdown handler once
+    if (!shutdownRegistered) {
+      registerShutdown();
+      shutdownRegistered = true;
+    }
+
+    // Initialize analytics (fast no-op if disabled)
+    await initAnalytics();
+
+    // Extract command name from constructor
+    const commandName = this.constructor.name
+      .replace(/Command$/, "")
+      .replace(/([A-Z])/g, " $1")
+      .trim()
+      .toLowerCase();
+
+    const startTime = Date.now();
+
+    try {
+      const result = await this.execute();
+
+      // Track successful command
+      telemetry.trackCommand(commandName, {
+        success: true,
+        duration_ms: Date.now() - startTime,
+        exit_code: 0,
+      });
+
+      return result;
+    } catch (err) {
+      const { message } = this.formatError(err);
+      const exitCode = getOclifExitCode(err) ?? errorToExitCode(err);
+
+      // Track failed command
+      telemetry.trackCommand(commandName, {
+        success: false,
+        duration_ms: Date.now() - startTime,
+        exit_code: exitCode,
+      });
+
+      // Track error type
+      const errorType = err instanceof Error ? err.constructor.name : "UnknownError";
+      telemetry.trackError(errorType, {
+        command: commandName,
+        recoverable: exitCode === 2, // Validation errors are recoverable
+      });
+
+      if (this.jsonErrorsEnabled()) {
+        console.error(JSON.stringify(toJsonError(err, exitCode), null, 2));
+        this.exit(exitCode);
+        return;
+      }
+      // If a subclass already called this.error(), rethrow unchanged
+      if (hasOclifExit(err)) {
+        throw err;
+      }
+      this.error(message, { exit: exitCode });
+    }
+  }
+
+  /**
+   * Format error for display.
+   */
+  protected formatError(err: unknown): { message: string; cause?: unknown } {
+    if (err instanceof Error) {
+      return { message: err.message, cause: err.cause };
+    }
+    return { message: String(err) };
+  }
+
+  protected jsonErrorsEnabled(): boolean {
+    const flags = this.parsedFlags as Record<string, unknown> | undefined;
+    if (typeof flags?.["json-errors"] === "boolean") {
+      return flags["json-errors"] as boolean;
+    }
+    const argv = process.argv.slice(2);
+    if (argv.includes("--no-json-errors") || argv.includes("--json-errors=false")) {
+      return false;
+    }
+    return argv.includes("--json-errors") || argv.includes("--json-errors=true");
+  }
+
+  /**
+   * Get plans directory path.
+   * Uses ~/.abbie/plans/ (dotfile convention like ~/.claude, ~/.codex)
+   */
+  protected getPlansDir(): string {
+    const home = process.env.HOME || "~";
+    return join(home, ".abbie", "plans");
+  }
+
+  /**
+   * Read from stdin if available (not a TTY).
+   * Returns empty string if stdin is a TTY or no data available.
+   */
+  protected async readStdin(): Promise<string> {
+    const { stdin } = process;
+    let result = "";
+
+    // Skip stdin reading if it's a TTY
+    if (stdin.isTTY) {
+      return "";
+    }
+
+    for await (const chunk of stdin) {
+      result += chunk;
+    }
+
+    return result.trim();
+  }
+
+  /**
+   * Output JSON data.
+   */
+  protected output(data: unknown): void {
+    this.log(JSON.stringify(data, null, 2));
+  }
+
+  /**
+   * Log info (suppressed in quiet or JSON mode).
+   */
+  protected logInfo(message: string): void {
+    if (this.parsedFlags?.quiet) return;
+    if (this.jsonEnabled?.()) return;
+    this.log(message);
+  }
+
+  /**
+   * Log warning (suppressed in JSON mode).
+   */
+  protected logWarn(message: string): void {
+    if (this.jsonEnabled?.()) return;
+    this.warn(message);
+  }
+
+  /**
+   * Check if NDJSON output is enabled.
+   */
+  protected ndjsonEnabled(): boolean {
+    const flags = this.parsedFlags as Record<string, unknown> | undefined;
+    if (typeof flags?.ndjson === "boolean") {
+      return flags.ndjson as boolean;
+    }
+    const argv = process.argv.slice(2);
+    if (argv.includes("--no-ndjson") || argv.includes("--ndjson=false")) {
+      return false;
+    }
+    return argv.includes("--ndjson") || argv.includes("--ndjson=true");
+  }
+
+  /**
+   * Output array items as NDJSON (one JSON object per line).
+   */
+  protected outputNdjson(items: unknown[]): void {
+    for (const item of items) {
+      this.log(JSON.stringify(item));
+    }
+  }
+}
+
+/**
+ * Type guard to check if error has oclif exit code.
+ */
+function hasOclifExit(err: unknown): err is { oclif: { exit: number } } {
+  if (typeof err !== "object" || err === null) return false;
+  if (!("oclif" in err)) return false;
+
+  const oclif = (err as { oclif?: unknown }).oclif;
+  if (typeof oclif !== "object" || oclif === null) return false;
+
+  const exit = (oclif as { exit?: unknown }).exit;
+  return typeof exit === "number";
+}
+
+function getOclifExitCode(err: unknown): number | undefined {
+  if (!hasOclifExit(err)) return undefined;
+  return err.oclif.exit;
+}