@creativeintelligence/abbie 0.1.4 → 0.1.6

package/dist/web/lib/paths.js

@@ -1,26 +0,0 @@
-export function formatDisplayPath(path) {
-    if (!path)
-        return '';
-    const normalized = path.replace(/^\/private\//, '/');
-    // macOS temp paths often land under /var/folders/.../T/..., but users think of it as /tmp
-    if (normalized.startsWith('/var/folders/') ||
-        normalized.startsWith('/tmp/') ||
-        normalized.startsWith('/tmp')) {
-        return '/tmp';
-    }
-    // Shorten home dir
-    if (normalized.startsWith('/Users/')) {
-        return normalized.replace(/^\/Users\/[^/]+/, '~');
-    }
-    return normalized;
-}
-export function formatTmuxWindowName(name) {
-    if (!name)
-        return '';
-    // Some tmux window names are synthetic and encode a working directory.
-    // Example: "basename:/private/tmp" -> "/tmp"
-    const basenameMatch = name.match(/basename:([^\s]+)/);
-    if (basenameMatch)
-        return formatDisplayPath(basenameMatch[1]);
-    return name;
-}

package/dist/web/lib/utils.d.ts

@@ -1,2 +0,0 @@
-import { type ClassValue } from 'clsx';
-export declare function cn(...inputs: ClassValue[]): any;

package/dist/web/lib/utils.js

@@ -1,5 +0,0 @@
-import { clsx } from 'clsx';
-import { twMerge } from 'tailwind-merge';
-export function cn(...inputs) {
-    return twMerge(clsx(inputs));
-}

package/dist/web/lib/ws.d.ts

@@ -1,18 +0,0 @@
-type MessageHandler = (data: unknown) => void;
-type ConnectionHandler = () => void;
-interface WSClient {
-    subscribe: (channel: string, handler: MessageHandler) => () => void;
-    unsubscribe: (channel: string) => void;
-    send: (message: unknown) => void;
-    onConnect: (handler: ConnectionHandler) => () => void;
-    onDisconnect: (handler: ConnectionHandler) => () => void;
-    connect: () => void;
-    disconnect: () => void;
-    isConnected: () => boolean;
-    subscribeTerminal: (window: string, pane?: number, session?: string) => void;
-    unsubscribeTerminal: () => void;
-    sendTerminalInput: (keys: string) => void;
-}
-export declare function createWSClient(url?: string): WSClient;
-export declare function getWSClient(): WSClient;
-export {};

package/dist/web/lib/ws.js

@@ -1,138 +0,0 @@
-export function createWSClient(url) {
-    // In dev: Next.js on 5173, API on 3847. In prod: both on same origin.
-    const wsUrl = url || (typeof window !== 'undefined' && window.location.port === '5173'
-        ? 'ws://localhost:3847/ws'
-        : typeof window !== 'undefined'
-            ? `ws://${window.location.host}/ws`
-            : 'ws://localhost:3847/ws');
-    let ws = null;
-    let reconnectTimeout = null;
-    const handlers = new Map();
-    const connectHandlers = new Set();
-    const disconnectHandlers = new Set();
-    const connect = () => {
-        // Already connected or connecting
-        if (ws?.readyState === WebSocket.OPEN || ws?.readyState === WebSocket.CONNECTING)
-            return;
-        console.log('[ws] creating new connection to', wsUrl);
-        ws = new WebSocket(wsUrl);
-        ws.onopen = () => {
-            console.log('[ws] connected, calling', connectHandlers.size, 'connect handlers');
-            connectHandlers.forEach((h) => h());
-            // Re-subscribe to all channels
-            handlers.forEach((_, channel) => {
-                ws?.send(JSON.stringify({ type: 'subscribe', channel }));
-            });
-        };
-        ws.onmessage = (event) => {
-            try {
-                const message = JSON.parse(event.data);
-                console.log('[ws] received message:', message.type);
-                const { type, data } = message;
-                // Handle channel messages
-                const channelHandlers = handlers.get(type);
-                if (channelHandlers) {
-                    channelHandlers.forEach((h) => h(data));
-                }
-                // Also notify wildcard subscribers
-                const wildcardHandlers = handlers.get('*');
-                if (wildcardHandlers) {
-                    wildcardHandlers.forEach((h) => h(message));
-                }
-            }
-            catch (e) {
-                console.error('[ws] parse error:', e);
-            }
-        };
-        ws.onclose = () => {
-            console.log('[ws] disconnected');
-            disconnectHandlers.forEach((h) => h());
-            // Reconnect after delay
-            reconnectTimeout = setTimeout(connect, 3000);
-        };
-        ws.onerror = (e) => {
-            console.error('[ws] error:', e);
-        };
-    };
-    const disconnect = () => {
-        if (reconnectTimeout) {
-            clearTimeout(reconnectTimeout);
-            reconnectTimeout = null;
-        }
-        ws?.close();
-        ws = null;
-    };
-    const subscribe = (channel, handler) => {
-        if (!handlers.has(channel)) {
-            handlers.set(channel, new Set());
-            // Subscribe on server only if connected
-            if (ws?.readyState === WebSocket.OPEN) {
-                ws.send(JSON.stringify({ type: 'subscribe', channel }));
-            }
-        }
-        handlers.get(channel).add(handler);
-        // Return unsubscribe function
-        return () => {
-            const channelHandlers = handlers.get(channel);
-            if (channelHandlers) {
-                channelHandlers.delete(handler);
-                if (channelHandlers.size === 0) {
-                    handlers.delete(channel);
-                    if (ws?.readyState === WebSocket.OPEN) {
-                        ws.send(JSON.stringify({ type: 'unsubscribe', channel }));
-                    }
-                }
-            }
-        };
-    };
-    const unsubscribe = (channel) => {
-        handlers.delete(channel);
-        ws?.send(JSON.stringify({ type: 'unsubscribe', channel }));
-    };
-    const send = (message) => {
-        if (ws?.readyState === WebSocket.OPEN) {
-            ws.send(JSON.stringify(message));
-        }
-    };
-    const onConnect = (handler) => {
-        connectHandlers.add(handler);
-        return () => connectHandlers.delete(handler);
-    };
-    const onDisconnect = (handler) => {
-        disconnectHandlers.add(handler);
-        return () => disconnectHandlers.delete(handler);
-    };
-    const subscribeTerminal = (window, pane = 0, session) => {
-        console.log('[ws] sending terminal:subscribe', { window, pane, session });
-        send({ type: 'terminal:subscribe', window, pane, session });
-    };
-    const unsubscribeTerminal = () => {
-        send({ type: 'terminal:unsubscribe' });
-    };
-    const sendTerminalInput = (keys) => {
-        const escaped = keys.replace(/\r/g, '\\r').replace(/\n/g, '\\n').replace(/\x7f/g, '\\x7f').replace(/\x1b/g, '\\e');
-        console.log('[ws] sendTerminalInput:', escaped);
-        send({ type: 'terminal:input', keys });
-    };
-    return {
-        subscribe,
-        unsubscribe,
-        send,
-        onConnect,
-        onDisconnect,
-        connect,
-        disconnect,
-        isConnected: () => ws?.readyState === WebSocket.OPEN,
-        subscribeTerminal,
-        unsubscribeTerminal,
-        sendTerminalInput,
-    };
-}
-// Global singleton
-let globalClient = null;
-export function getWSClient() {
-    if (!globalClient) {
-        globalClient = createWSClient();
-    }
-    return globalClient;
-}

package/dist/web/next.config.d.ts

@@ -1,3 +0,0 @@
-import type { NextConfig } from 'next';
-declare const config: NextConfig;
-export default config;

package/dist/web/next.config.js

@@ -1,9 +0,0 @@
-const config = {
-    // Static export only for production builds, not dev
-    output: process.env.NODE_ENV === 'production' ? 'export' : undefined,
-    distDir: 'dist',
-    images: {
-        unoptimized: true,
-    },
-};
-export default config;

package/scripts/generate-manifest.ts

@@ -1,44 +0,0 @@
-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

@@ -1,233 +0,0 @@
-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;
-}