@creativeintelligence/abbie 0.1.4 → 0.1.5

package/src/cli/commands/__tests__/bridge.test.ts

@@ -1,101 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { existsSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { spawnSync } from "node:child_process";
-
-describe("bridge command", () => {
-  const repoRoot = resolve(__dirname, "../../../../../..");
-
-  it("bridge script exists and is reachable from CLI", () => {
-    const scriptPath = join(repoRoot, "scripts", "pi-bridge.ts");
-    expect(existsSync(scriptPath)).toBe(true);
-  });
-
-  it("CLI symlink points to the bridge script", () => {
-    const symlinkPath = join(repoRoot, "apps", "cli", "scripts", "pi-bridge.ts");
-    expect(existsSync(symlinkPath)).toBe(true);
-  });
-
-  it("bridge script is valid TypeScript (can be parsed)", () => {
-    const scriptPath = join(repoRoot, "scripts", "pi-bridge.ts");
-    // Just verify it can be read without errors
-    const result = spawnSync(
-      "node",
-      ["--experimental-strip-types", "-e", `require("fs").readFileSync("${scriptPath}", "utf8")`],
-      { encoding: "utf8", timeout: 5000 },
-    );
-    expect(result.status).toBe(0);
-  });
-});
-
-describe("bridge config resolution", () => {
-  it("parseDotEnv handles standard .env format", () => {
-    // Test the parsing logic inline since it's in the bridge command
-    const parseDotEnv = (content: string): Record<string, string> => {
-      const env: Record<string, string> = {};
-      for (const rawLine of content.split("\n")) {
-        const line = rawLine.trim();
-        if (!line || line.startsWith("#")) continue;
-        const idx = line.indexOf("=");
-        if (idx <= 0) continue;
-        const key = line.slice(0, idx).trim();
-        let value = line.slice(idx + 1).trim();
-        if (
-          (value.startsWith('"') && value.endsWith('"')) ||
-          (value.startsWith("'") && value.endsWith("'"))
-        ) {
-          value = value.slice(1, -1);
-        }
-        if (key) env[key] = value;
-      }
-      return env;
-    };
-
-    const result = parseDotEnv(`
-# Comment line
-CONVEX_URL=https://test.convex.cloud
-ABBIE_BRIDGE_SECRET="my-secret"
-PI_MODEL='claude-sonnet-4.6'
-EMPTY_VALUE=
-    `);
-
-    expect(result.CONVEX_URL).toBe("https://test.convex.cloud");
-    expect(result.ABBIE_BRIDGE_SECRET).toBe("my-secret");
-    expect(result.PI_MODEL).toBe("claude-sonnet-4.6");
-    expect(result.EMPTY_VALUE).toBe("");
-  });
-
-  it("parseDotEnv skips comments and empty lines", () => {
-    const parseDotEnv = (content: string): Record<string, string> => {
-      const env: Record<string, string> = {};
-      for (const rawLine of content.split("\n")) {
-        const line = rawLine.trim();
-        if (!line || line.startsWith("#")) continue;
-        const idx = line.indexOf("=");
-        if (idx <= 0) continue;
-        const key = line.slice(0, idx).trim();
-        let value = line.slice(idx + 1).trim();
-        if (
-          (value.startsWith('"') && value.endsWith('"')) ||
-          (value.startsWith("'") && value.endsWith("'"))
-        ) {
-          value = value.slice(1, -1);
-        }
-        if (key) env[key] = value;
-      }
-      return env;
-    };
-
-    const result = parseDotEnv(`
-# This is a comment
-# Another comment
-
-KEY=value
-
-# More comments
-`);
-
-    expect(Object.keys(result)).toEqual(["KEY"]);
-    expect(result.KEY).toBe("value");
-  });
-});

package/src/cli/commands/__tests__/daemon.test.ts

@@ -1,79 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-type ExecuteQueuedCommandResult = { success: boolean; sessionId?: string; error?: string };
-type ExecuteQueuedCommand = (command: string, args: unknown) => Promise<ExecuteQueuedCommandResult>;
-
-const startSpy = vi.fn(async () => ({ session_id: "sess_test_123" }));
-
-vi.mock("@creativeintelligence/sdk/convex", () => ({
-  api: {},
-  closeClients: vi.fn(),
-  getHttpClient: vi.fn(),
-  isConvexConfigured: vi.fn(() => true),
-  subscribe: vi.fn(),
-}));
-
-vi.mock("../../../lib/active-sessions.js", () => ({
-  getActiveSessionManager: () => ({ start: startSpy }),
-}));
-
-describe("executeQueuedCommand", () => {
-  beforeEach(() => {
-    startSpy.mockClear();
-  });
-
-  it('should handle "abbie session start" command', async () => {
-    const { default: DaemonCommand } = await import("../daemon.ts");
-
-    const exec = (
-      DaemonCommand as unknown as { prototype: { executeQueuedCommand: ExecuteQueuedCommand } }
-    ).prototype.executeQueuedCommand;
-
-    const result = await exec("abbie session start", {
-      agent: "codex",
-      project: "arbor",
-      goal: "Implement ARBOR-123",
-      issue: "ARBOR-123",
-      cwd: "/tmp/arbor",
-    });
-
-    expect(startSpy).toHaveBeenCalledTimes(1);
-    expect(startSpy).toHaveBeenCalledWith({
-      agent: "codex",
-      project: "arbor",
-      goal: "Implement ARBOR-123",
-      issue: "ARBOR-123",
-      cwd: "/tmp/arbor",
-    });
-    expect(result).toEqual({ success: true, sessionId: "sess_test_123" });
-  });
-
-  it("should return error for unknown command", async () => {
-    const { default: DaemonCommand } = await import("../daemon.ts");
-
-    const exec = (
-      DaemonCommand as unknown as { prototype: { executeQueuedCommand: ExecuteQueuedCommand } }
-    ).prototype.executeQueuedCommand;
-
-    const result = await exec("abbie nope", {});
-    expect(result).toEqual({ success: false, error: "Unknown command: abbie nope" });
-  });
-
-  it("should handle missing required args gracefully", async () => {
-    const { default: DaemonCommand } = await import("../daemon.ts");
-
-    const exec = (
-      DaemonCommand as unknown as { prototype: { executeQueuedCommand: ExecuteQueuedCommand } }
-    ).prototype.executeQueuedCommand;
-
-    const result = await exec("abbie session start", {
-      project: "arbor",
-      // agent missing
-      goal: "Missing agent",
-    });
-
-    expect(startSpy).not.toHaveBeenCalled();
-    expect(result.success).toBe(false);
-    expect(result.error).toContain("abbie session start");
-  });
-});

package/src/cli/commands/agent/list.ts

@@ -1,75 +0,0 @@
-import { Command, Flags } from "@oclif/core";
-import { AGENT_METADATA, getAvailableAgents } from "../../../lib/agent-adapters.js";
-import { AGENTS } from "../../../lib/types.js";
-
-export default class AgentList extends Command {
-  static override description = "List available AI coding agents";
-
-  static override examples = [
-    "<%= config.bin %> <%= command.id %>",
-    "<%= config.bin %> <%= command.id %> --available",
-    "<%= config.bin %> <%= command.id %> --json --quiet",
-  ];
-
-  static override flags = {
-    available: Flags.boolean({
-      char: "a",
-      description: "Only show installed/available agents",
-      default: false,
-    }),
-    json: Flags.boolean({
-      description: "Output as JSON",
-      default: false,
-    }),
-    quiet: Flags.boolean({
-      char: "q",
-      description: "Suppress info messages",
-      default: false,
-    }),
-  };
-
-  async run(): Promise<void> {
-    const { flags } = await this.parse(AgentList);
-    const availableAgents = await getAvailableAgents();
-
-    const agents = AGENTS.map((type) => {
-      const meta = AGENT_METADATA[type];
-      const isAvailable = availableAgents.includes(type);
-
-      return {
-        type,
-        name: meta.name,
-        description: meta.description,
-        available: isAvailable,
-        installCmd: meta.installCmd,
-      };
-    });
-
-    const filtered = flags.available ? agents.filter((a) => a.available) : agents;
-
-    if (flags.json) {
-      this.log(JSON.stringify(filtered, null, 2));
-      return;
-    }
-
-    if (!flags.quiet) {
-      this.log("\nAI Coding Agents\n");
-    }
-
-    for (const agent of filtered) {
-      const status = agent.available ? "✓" : "✗";
-      const color = agent.available ? "\x1b[32m" : "\x1b[31m";
-      this.log(
-        `  ${color}${status}\x1b[0m ${agent.type.padEnd(10)} ${agent.name} - ${agent.description}`,
-      );
-      if (!agent.available && agent.installCmd) {
-        this.log(`              Install: ${agent.installCmd}`);
-      }
-    }
-
-    if (!flags.quiet) {
-      const availableCount = filtered.filter((a) => a.available).length;
-      this.log(`\n${availableCount}/${filtered.length} agents available`);
-    }
-  }
-}

package/src/cli/commands/annotation/ack.ts

@@ -1,37 +0,0 @@
-import { Args } from "@oclif/core";
-import { ConvexAnnotationClient } from "../../../lib/annotations-convex.js";
-import { BaseCommand } from "../../base-command.js";
-
-export default class AnnotationAck extends BaseCommand {
-  static override description = "Acknowledge an annotation (mark as seen)";
-  static override hidden = false;
-
-  static override examples = ["<%= config.bin %> annotation ack PREVIEW_ID ANNOTATION_ID"];
-
-  static override args = {
-    previewId: Args.string({ description: "Preview deployment ID", required: true }),
-    annotationId: Args.string({ description: "Annotation ID", required: true }),
-  };
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { args, flags } = await this.parse(AnnotationAck);
-    this.parsedFlags = flags;
-
-    const client = new ConvexAnnotationClient();
-    const annotation = await client.acknowledge(args.previewId, args.annotationId);
-
-    if (!annotation) {
-      this.error(`Annotation ${args.annotationId} not found`);
-    }
-
-    const isJson = flags.json || flags.format === "json";
-    if (isJson) return annotation;
-
-    this.logInfo(`Acknowledged ${annotation.id.slice(0, 8)}`);
-    return annotation;
-  }
-}

package/src/cli/commands/annotation/create.ts

@@ -1,67 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import type { AnnotationIntent, AnnotationSeverity } from "../../../lib/annotations.js";
-import { ConvexAnnotationClient } from "../../../lib/annotations-convex.js";
-import { BaseCommand } from "../../base-command.js";
-
-export default class AnnotationCreate extends BaseCommand {
-  static override description = "Create an annotation on a preview deployment";
-  static override hidden = false;
-
-  static override examples = [
-    '<%= config.bin %> annotation create PREVIEW_ID "Button text is truncated on mobile"',
-    '<%= config.bin %> annotation create PREVIEW_ID "Auth redirect broken" --severity error --intent bug',
-    '<%= config.bin %> annotation create PREVIEW_ID "Consider lazy loading" --intent suggestion --target /dashboard',
-  ];
-
-  static override args = {
-    previewId: Args.string({ description: "Preview deployment ID", required: true }),
-    body: Args.string({ description: "Annotation body (markdown)", required: true }),
-  };
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    severity: Flags.string({
-      description: "Severity level",
-      options: ["info", "warning", "error", "critical"],
-      default: "info",
-    }),
-    intent: Flags.string({
-      description: "Annotation intent",
-      options: ["feedback", "bug", "suggestion", "question", "blocker"],
-      default: "feedback",
-    }),
-    source: Flags.string({
-      description: "Source tool creating this annotation",
-      default: "cli",
-    }),
-    target: Flags.string({
-      description: "URL path or element being annotated",
-    }),
-    selector: Flags.string({
-      description: "CSS selector for the annotated element",
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { args, flags } = await this.parse(AnnotationCreate);
-    this.parsedFlags = flags;
-
-    const client = new ConvexAnnotationClient();
-    const annotation = await client.create({
-      previewId: args.previewId,
-      body: args.body,
-      severity: flags.severity as AnnotationSeverity,
-      intent: flags.intent as AnnotationIntent,
-      source: flags.source,
-      target: flags.target,
-      selector: flags.selector,
-    });
-
-    const isJson = flags.json || flags.format === "json";
-
-    if (isJson) return annotation;
-
-    this.logInfo(`Created annotation ${annotation.id.slice(0, 8)} [${annotation.status}]`);
-    return annotation;
-  }
-}

package/src/cli/commands/annotation/events.ts

@@ -1,63 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { AnnotationStore } from "../../../lib/annotations.js";
-import { BaseCommand } from "../../base-command.js";
-
-export default class AnnotationEvents extends BaseCommand {
-  static override description =
-    "List or export annotation event envelopes for a preview deployment";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> annotation events PREVIEW_ID",
-    "<%= config.bin %> annotation events PREVIEW_ID --session-id sess_abc",
-    "<%= config.bin %> annotation events PREVIEW_ID --ndjson -q",
-  ];
-
-  static override args = {
-    previewId: Args.string({
-      description: "Preview deployment ID",
-      required: true,
-    }),
-  };
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    "session-id": Flags.string({
-      description:
-        "Override session ID in event envelopes (default: per-annotation linkedSessionId)",
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { args, flags } = await this.parse(AnnotationEvents);
-    this.parsedFlags = flags;
-
-    const store = new AnnotationStore();
-    const envelopes = store.exportEvents(args.previewId, {
-      sessionId: flags["session-id"],
-    });
-
-    if (this.ndjsonEnabled()) {
-      this.outputNdjson(envelopes);
-      return;
-    }
-
-    const isJson = flags.json || flags.format === "json";
-    if (isJson) {
-      return envelopes;
-    }
-
-    if (envelopes.length === 0) {
-      this.logInfo("No events found");
-      return [];
-    }
-
-    for (const env of envelopes) {
-      const e = env.event;
-      const session = env.sessionId ? ` [${env.sessionId}]` : "";
-      this.log(`#${e.seq} ${e.type} ${e.annotationId.slice(0, 8)}${session} @ ${e.timestamp}`);
-    }
-
-    return envelopes;
-  }
-}

package/src/cli/commands/annotation/export.ts

@@ -1,67 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { AnnotationStore } from "../../../lib/annotations.js";
-import { BaseCommand } from "../../base-command.js";
-
-export default class AnnotationExport extends BaseCommand {
-  static override description = "Export annotations as AFS payload(s) from a preview deployment";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> annotation export PREVIEW_ID",
-    "<%= config.bin %> annotation export PREVIEW_ID ANNOTATION_ID",
-    "<%= config.bin %> annotation export PREVIEW_ID --status pending",
-    "<%= config.bin %> annotation export PREVIEW_ID --ndjson",
-  ];
-
-  static override args = {
-    previewId: Args.string({
-      description: "Preview deployment ID",
-      required: true,
-    }),
-    annotationId: Args.string({
-      description: "Single annotation ID to export (omit for batch)",
-      required: false,
-    }),
-  };
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    status: Flags.string({
-      char: "s",
-      description: "Filter by status (batch mode only)",
-      options: ["pending", "acknowledged", "resolved", "dismissed"],
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { args, flags } = await this.parse(AnnotationExport);
-    this.parsedFlags = flags;
-
-    const store = new AnnotationStore();
-
-    // Single export
-    if (args.annotationId) {
-      const afs = store.exportAfs(args.previewId, args.annotationId);
-      if (!afs) {
-        this.error(`Annotation ${args.annotationId} not found`);
-      }
-      return afs;
-    }
-
-    // Batch export
-    const filter = flags.status ? { status: flags.status as "pending" } : undefined;
-    const results = store.exportAfsBatch(args.previewId, filter);
-
-    if (this.ndjsonEnabled()) {
-      this.outputNdjson(results);
-      return;
-    }
-
-    if (results.length === 0) {
-      this.logInfo("No annotations to export");
-      return [];
-    }
-
-    return results;
-  }
-}

package/src/cli/commands/annotation/import.ts

@@ -1,98 +0,0 @@
-import { readFileSync } from "node:fs";
-import { Args, Flags } from "@oclif/core";
-import type { AfsAnnotation } from "../../../lib/annotations.js";
-import { AnnotationStore } from "../../../lib/annotations.js";
-import { BaseCommand } from "../../base-command.js";
-
-export default class AnnotationImport extends BaseCommand {
-  static override description = "Import AFS annotation payload(s) into a preview deployment";
-  static override hidden = false;
-
-  static override examples = [
-    'echo \'{"id":"ann_1","comment":"Fix button","elementPath":"body","timestamp":0,"x":0,"y":0,"element":"div"}\' | <%= config.bin %> annotation import PREVIEW_ID',
-    "<%= config.bin %> annotation import PREVIEW_ID --file annotations.json",
-    "<%= config.bin %> annotation import PREVIEW_ID --file batch.json --batch",
-  ];
-
-  static override args = {
-    previewId: Args.string({
-      description: "Preview deployment ID",
-      required: true,
-    }),
-  };
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    file: Flags.string({
-      char: "f",
-      description: "Path to AFS JSON file (single object or array)",
-    }),
-    batch: Flags.boolean({
-      description: "Treat input as a JSON array of AFS annotations",
-      default: false,
-    }),
-    source: Flags.string({
-      description: "Source identifier for imported annotations",
-      default: "agentation-afs",
-    }),
-    "session-id": Flags.string({
-      description: "Link imported annotations to this session ID",
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { args, flags } = await this.parse(AnnotationImport);
-    this.parsedFlags = flags;
-
-    let raw: string;
-    if (flags.file) {
-      raw = readFileSync(flags.file, "utf-8").trim();
-    } else {
-      raw = await this.readStdin();
-      if (!raw) {
-        this.error("No input provided. Pipe AFS JSON via stdin or use --file.");
-      }
-    }
-
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(raw);
-    } catch {
-      this.error("Invalid JSON input");
-    }
-
-    const store = new AnnotationStore();
-    const parsedIsArray = Array.isArray(parsed);
-    if (flags.batch && !parsedIsArray) {
-      this.error("Batch mode expects a JSON array of AFS annotations");
-    }
-
-    const isBatch = flags.batch || parsedIsArray;
-    const afsPayloads: AfsAnnotation[] = parsedIsArray
-      ? (parsed as AfsAnnotation[])
-      : [parsed as AfsAnnotation];
-
-    const results = store.importAfsBatch({
-      previewId: args.previewId,
-      annotations: afsPayloads,
-      source: flags.source,
-    });
-
-    // Link session if provided
-    if (flags["session-id"]) {
-      for (const annotation of results) {
-        store.linkSession(args.previewId, annotation.id, flags["session-id"]);
-      }
-    }
-
-    const isJson = flags.json || flags.format === "json";
-    if (isJson) {
-      return isBatch ? results : results[0];
-    }
-
-    this.logInfo(
-      `Imported ${results.length} annotation${results.length !== 1 ? "s" : ""} into ${args.previewId}`
-    );
-    return isBatch ? results : results[0];
-  }
-}