@creativeintelligence/abbie 0.1.3 → 0.1.5

package/src/cli/commands/triage/claim.ts

@@ -1,203 +0,0 @@
-import { Flags } from "@oclif/core";
-import { fetchLinearIssues, type LinearIssue } from "../../../lib/triage.js";
-import { classifyWithLLM } from "../../../lib/triage-llm.js";
-import { createTrackingIssue, isTracked } from "../../../lib/triage-tracker.js";
-import { BaseCommand } from "../../base-command.js";
-
-export default class TriageClaim extends BaseCommand {
-  static override description =
-    "Claim next issue: LLM classifies from source workspace, creates tracking issue in luke-labs";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> triage claim",
-    "<%= config.bin %> triage claim --source-workspace zocomputer --source-team ZO",
-    "<%= config.bin %> triage claim --agent copilot",
-    "<%= config.bin %> triage claim --dry-run",
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    "source-workspace": Flags.string({
-      char: "s",
-      description: "Source workspace (where real issues live)",
-      default: "zocomputer",
-    }),
-    "source-team": Flags.string({
-      char: "t",
-      description: "Source team",
-      default: "ZO",
-    }),
-    "tracking-workspace": Flags.string({
-      description: "Tracking workspace (for agent work)",
-      default: "luke-labs",
-    }),
-    "tracking-team": Flags.string({
-      description: "Tracking team",
-      default: "ZO",
-    }),
-    agent: Flags.string({
-      char: "a",
-      description: "Filter by agent capability after classification",
-      options: ["copilot", "claude", "codex", "human"],
-    }),
-    assignee: Flags.string({
-      description: "Filter source issues by assignee",
-      default: "luke",
-    }),
-    state: Flags.string({
-      description: "Filter source issues by state",
-      multiple: true,
-      default: ["Todo", "Backlog"],
-    }),
-    "dry-run": Flags.boolean({
-      char: "n",
-      description: "Classify but do not create tracking issue",
-      default: false,
-    }),
-    limit: Flags.integer({
-      char: "l",
-      description: "Max issues to consider from source",
-      default: 20,
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { flags } = await this.parse(TriageClaim);
-    this.parsedFlags = flags;
-
-    // Fetch source issues
-    this.logInfo(`Fetching issues from ${flags["source-workspace"]}/${flags["source-team"]}...`);
-
-    const issues = await fetchLinearIssues({
-      workspace: flags["source-workspace"],
-      team: flags["source-team"],
-      assignee: flags.assignee,
-      states: flags.state,
-      limit: flags.limit,
-    });
-
-    if (issues.length === 0) {
-      if (flags.json || flags.format === "json") {
-        return { status: "no_issues", message: "No issues found in source" };
-      }
-      this.logInfo("No issues found in source workspace");
-      return { status: "no_issues" };
-    }
-
-    // Find first untracked issue
-    let targetIssue: LinearIssue | null = null;
-    for (const issue of issues) {
-      const tracked = isTracked(issue.identifier);
-      if (!tracked || tracked.status === "done") {
-        targetIssue = issue;
-        break;
-      }
-    }
-
-    if (!targetIssue) {
-      if (flags.json || flags.format === "json") {
-        return { status: "all_tracked", message: "All source issues are already tracked" };
-      }
-      this.logInfo("All source issues are already tracked");
-      return { status: "all_tracked" };
-    }
-
-    // LLM classification
-    this.logInfo(`Classifying ${targetIssue.identifier}: ${targetIssue.title}`);
-    const classification = await classifyWithLLM(targetIssue);
-
-    // Filter by agent if specified
-    if (flags.agent && classification.agent !== flags.agent) {
-      // Find another issue that matches the agent filter
-      for (const issue of issues) {
-        if (issue.identifier === targetIssue.identifier) continue;
-        const tracked = isTracked(issue.identifier);
-        if (tracked && tracked.status !== "done") continue;
-
-        const cls = await classifyWithLLM(issue);
-        if (cls.agent === flags.agent) {
-          targetIssue = issue;
-          Object.assign(classification, cls);
-          break;
-        }
-      }
-
-      if (classification.agent !== flags.agent) {
-        if (flags.json || flags.format === "json") {
-          return {
-            status: "no_match",
-            message: `No issues found suitable for ${flags.agent} agent`,
-          };
-        }
-        this.logInfo(`No issues found suitable for ${flags.agent} agent`);
-        return { status: "no_match" };
-      }
-    }
-
-    // Create tracking issue
-    const tracking = await createTrackingIssue(targetIssue, classification, {
-      sourceWorkspace: flags["source-workspace"],
-      sourceTeam: flags["source-team"],
-      trackingWorkspace: flags["tracking-workspace"],
-      trackingTeam: flags["tracking-team"],
-      dryRun: flags["dry-run"],
-    });
-
-    if (flags.json || flags.format === "json") {
-      return {
-        status: "claimed",
-        source: {
-          identifier: targetIssue.identifier,
-          title: targetIssue.title,
-          url: tracking.source_url,
-        },
-        classification: {
-          type: classification.type,
-          complexity: classification.complexity,
-          agent: classification.agent,
-          confidence: classification.confidence,
-          reasoning: classification.reasoning,
-          suggested_prompt: classification.suggested_prompt,
-          tags: classification.tags,
-        },
-        tracking: {
-          identifier: tracking.tracking_identifier,
-          url: tracking.tracking_url,
-          workspace: flags["tracking-workspace"],
-          team: flags["tracking-team"],
-        },
-        dry_run: flags["dry-run"],
-      };
-    }
-
-    // Human-readable output
-    this.log("");
-    this.log(`${flags["dry-run"] ? "[DRY RUN] " : ""}Claimed: ${targetIssue.identifier}`);
-    this.log(`Title: ${targetIssue.title}`);
-    this.log("");
-    this.log("Classification:");
-    this.log(`  Type:       ${classification.type}`);
-    this.log(`  Complexity: ${classification.complexity}`);
-    this.log(`  Agent:      ${classification.agent}`);
-    this.log(`  Confidence: ${classification.confidence}/10`);
-    this.log("");
-    this.log("Reasoning:");
-    this.log(`  ${classification.reasoning}`);
-    this.log("");
-    this.log("Suggested Prompt:");
-    this.log(`  ${classification.suggested_prompt}`);
-    this.log("");
-
-    if (!flags["dry-run"] && tracking.tracking_identifier) {
-      this.log(`Tracking: ${tracking.tracking_identifier}`);
-      this.log(`URL: ${tracking.tracking_url}`);
-    }
-
-    return {
-      status: "claimed",
-      source: targetIssue.identifier,
-      tracking: tracking.tracking_identifier,
-    };
-  }
-}

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

@@ -1,137 +0,0 @@
-import { Flags } from "@oclif/core";
-import {
-  type AgentCapability,
-  type Complexity,
-  createTriageManager,
-  type IssueType,
-} from "../../../lib/triage.js";
-import { BaseCommand } from "../../base-command.js";
-
-export default class TriageList extends BaseCommand {
-  static override description = "List triaged issues with optional filters";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> triage list --workspace zocomputer --team ZO",
-    "<%= config.bin %> triage list -w zocomputer -t ZO --agent claude",
-    "<%= config.bin %> triage list -w zocomputer -t ZO --type bug --complexity simple",
-    "<%= config.bin %> triage list -w zocomputer -t ZO --ids",
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    workspace: Flags.string({
-      char: "w",
-      description: "Linear workspace",
-      required: true,
-    }),
-    team: Flags.string({
-      char: "t",
-      description: "Linear team",
-      required: true,
-    }),
-    agent: Flags.string({
-      char: "a",
-      description: "Filter by agent",
-      options: ["claude", "codex", "copilot", "human"],
-    }),
-    type: Flags.string({
-      description: "Filter by issue type",
-      options: ["bug", "feature", "refactor", "improvement", "chore", "unknown"],
-    }),
-    complexity: Flags.string({
-      char: "c",
-      description: "Filter by complexity",
-      options: ["trivial", "simple", "medium", "complex", "epic"],
-    }),
-    pending: Flags.boolean({
-      char: "p",
-      description: "Only show pending (not queued) issues",
-      default: false,
-    }),
-    ids: Flags.boolean({
-      description: "Output only issue identifiers (for piping)",
-      default: false,
-    }),
-    limit: Flags.integer({
-      char: "l",
-      description: "Limit output",
-      default: 20,
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { flags } = await this.parse(TriageList);
-    this.parsedFlags = flags;
-
-    const manager = createTriageManager();
-    const queue = manager.load(flags.workspace, flags.team);
-
-    if (!queue) {
-      if (flags.json || flags.format === "json") {
-        return { issues: [] };
-      }
-      this.error(`No queue found for ${flags.workspace}/${flags.team}. Run 'triage pull' first.`);
-    }
-
-    // Filter issues
-    let issues = queue.issues;
-
-    if (flags.agent) {
-      issues = issues.filter((i) => i.agent === (flags.agent as AgentCapability));
-    }
-
-    if (flags.type) {
-      issues = issues.filter((i) => i.type === (flags.type as IssueType));
-    }
-
-    if (flags.complexity) {
-      issues = issues.filter((i) => i.complexity === (flags.complexity as Complexity));
-    }
-
-    if (flags.pending) {
-      issues = issues.filter((i) => !i.queued_at);
-    }
-
-    // Apply limit
-    issues = issues.slice(0, flags.limit);
-
-    if (flags.json || flags.format === "json") {
-      return { issues };
-    }
-
-    // NDJSON: one issue per line
-    if (this.ndjsonEnabled()) {
-      this.outputNdjson(issues);
-      return { issues };
-    }
-
-    // IDs only (for piping)
-    if (flags.ids) {
-      for (const issue of issues) {
-        this.log(issue.issue.identifier);
-      }
-      return { issues };
-    }
-
-    // Human-readable output
-    if (issues.length === 0) {
-      this.logInfo("No matching issues");
-      return { issues: [] };
-    }
-
-    this.log("");
-    for (const issue of issues) {
-      const status = issue.queued_at ? "✓" : "○";
-      const tags = issue.tags.length > 0 ? ` [${issue.tags.slice(0, 3).join(", ")}]` : "";
-      this.log(
-        `${status} ${issue.issue.identifier} ${issue.agent}/${issue.type}/${issue.complexity}`,
-      );
-      this.log(`  ${issue.issue.title}${tags}`);
-      this.log(`  confidence: ${issue.confidence} | ${issue.reason}`);
-      this.log("");
-    }
-
-    return { issues };
-  }
-}

package/src/cli/commands/triage/next.ts

@@ -1,73 +0,0 @@
-import { Flags } from "@oclif/core";
-import { type AgentCapability, createTriageManager } from "../../../lib/triage.js";
-import { BaseCommand } from "../../base-command.js";
-
-export default class TriageNext extends BaseCommand {
-  static override description = "Get next issue for an agent from triage queue";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> triage next --workspace zocomputer --team ZO --agent claude",
-    "<%= config.bin %> triage next -w zocomputer -t ZO -a codex --json",
-    "<%= config.bin %> triage next -w zocomputer -t ZO -a copilot | xargs linear issue view",
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    workspace: Flags.string({
-      char: "w",
-      description: "Linear workspace",
-      required: true,
-    }),
-    team: Flags.string({
-      char: "t",
-      description: "Linear team",
-      required: true,
-    }),
-    agent: Flags.string({
-      char: "a",
-      description: "Agent type (claude, codex, copilot, human)",
-      required: true,
-      options: ["claude", "codex", "copilot", "human"],
-    }),
-    mark: Flags.boolean({
-      char: "m",
-      description: "Mark issue as queued",
-      default: false,
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { flags } = await this.parse(TriageNext);
-    this.parsedFlags = flags;
-
-    const manager = createTriageManager();
-    const agent = flags.agent as AgentCapability;
-
-    const issue = manager.next(flags.workspace, flags.team, agent);
-
-    if (!issue) {
-      if (flags.json || flags.format === "json") {
-        return { found: false };
-      }
-      this.logInfo(`No issues available for ${agent}`);
-      return { found: false };
-    }
-
-    // Mark as queued if requested
-    if (flags.mark) {
-      manager.markQueued(flags.workspace, flags.team, issue.issue.identifier);
-    }
-
-    if (flags.json || flags.format === "json") {
-      return {
-        found: true,
-        ...issue,
-      };
-    }
-
-    // Unix pipe output: just the identifier
-    this.log(issue.issue.identifier);
-    return { found: true, identifier: issue.issue.identifier };
-  }
-}

package/src/cli/commands/triage/pull.ts

@@ -1,97 +0,0 @@
-import { Flags } from "@oclif/core";
-import { createTriageManager } from "../../../lib/triage.js";
-import { BaseCommand } from "../../base-command.js";
-
-export default class TriagePull extends BaseCommand {
-  static override description = "Pull and triage issues from Linear workspace";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> triage pull --workspace zocomputer --team ZO",
-    "<%= config.bin %> triage pull --workspace zocomputer --team ZO --assignee luke",
-    "<%= config.bin %> triage pull --workspace zocomputer --team ZO --json",
-    '<%= config.bin %> triage pull -w zocomputer -t ZO | jq ".issues[] | .issue.identifier"',
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    workspace: Flags.string({
-      char: "w",
-      description: "Linear workspace",
-      required: true,
-    }),
-    team: Flags.string({
-      char: "t",
-      description: "Linear team",
-      required: true,
-    }),
-    assignee: Flags.string({
-      char: "a",
-      description: "Filter by assignee",
-    }),
-    state: Flags.string({
-      char: "s",
-      description: "Filter by state (can be repeated)",
-      multiple: true,
-    }),
-    limit: Flags.integer({
-      char: "l",
-      description: "Maximum issues to pull",
-      default: 50,
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { flags } = await this.parse(TriagePull);
-    this.parsedFlags = flags;
-
-    const manager = createTriageManager();
-
-    const queue = manager.refresh({
-      workspace: flags.workspace,
-      team: flags.team,
-      assignee: flags.assignee,
-      states: flags.state,
-      limit: flags.limit,
-    });
-
-    if (flags.json || flags.format === "json") {
-      return queue;
-    }
-
-    // Human-readable output
-    this.log(`\nTriaged ${queue.issues.length} issues from ${flags.workspace}/${flags.team}\n`);
-
-    const stats = manager.stats(flags.workspace, flags.team);
-    if (stats) {
-      this.log("By Agent:");
-      for (const [agent, count] of Object.entries(stats.byAgent)) {
-        this.log(`  ${agent}: ${count}`);
-      }
-      this.log("");
-
-      this.log("By Type:");
-      for (const [type, count] of Object.entries(stats.byType)) {
-        this.log(`  ${type}: ${count}`);
-      }
-      this.log("");
-
-      this.log("By Complexity:");
-      for (const [complexity, count] of Object.entries(stats.byComplexity)) {
-        this.log(`  ${complexity}: ${count}`);
-      }
-      this.log("");
-    }
-
-    // Show top 5 issues
-    this.log("Top Issues:");
-    for (const issue of queue.issues.slice(0, 5)) {
-      const tags = issue.tags.length > 0 ? ` [${issue.tags.join(", ")}]` : "";
-      this.log(
-        `  ${issue.issue.identifier} (${issue.agent}/${issue.complexity}): ${issue.issue.title}${tags}`,
-      );
-    }
-
-    return queue;
-  }
-}

package/src/cli/commands/triage/stats.ts

@@ -1,82 +0,0 @@
-import { Flags } from "@oclif/core";
-import { createTriageManager } from "../../../lib/triage.js";
-import { BaseCommand } from "../../base-command.js";
-
-export default class TriageStats extends BaseCommand {
-  static override description = "Show triage queue statistics";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> triage stats --workspace zocomputer --team ZO",
-    "<%= config.bin %> triage stats -w zocomputer -t ZO --json",
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    workspace: Flags.string({
-      char: "w",
-      description: "Linear workspace",
-      required: true,
-    }),
-    team: Flags.string({
-      char: "t",
-      description: "Linear team",
-      required: true,
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { flags } = await this.parse(TriageStats);
-    this.parsedFlags = flags;
-
-    const manager = createTriageManager();
-    const stats = manager.stats(flags.workspace, flags.team);
-
-    if (!stats) {
-      if (flags.json || flags.format === "json") {
-        return { found: false };
-      }
-      this.error(`No queue found for ${flags.workspace}/${flags.team}. Run 'triage pull' first.`);
-    }
-
-    if (flags.json || flags.format === "json") {
-      return stats;
-    }
-
-    // Human-readable output
-    this.log(`\nTriage Queue: ${flags.workspace}/${flags.team}\n`);
-    this.log(`Total: ${stats.total}`);
-    this.log(`Pending: ${stats.pending}`);
-    this.log(`Queued: ${stats.queued}`);
-    this.log("");
-
-    this.log("By Agent:");
-    for (const [agent, count] of Object.entries(stats.byAgent)) {
-      const pct = ((count / stats.total) * 100).toFixed(0);
-      this.log(`  ${agent.padEnd(8)} ${String(count).padStart(3)} (${pct}%)`);
-    }
-    this.log("");
-
-    this.log("By Type:");
-    for (const [type, count] of Object.entries(stats.byType)) {
-      const pct = ((count / stats.total) * 100).toFixed(0);
-      this.log(`  ${type.padEnd(12)} ${String(count).padStart(3)} (${pct}%)`);
-    }
-    this.log("");
-
-    this.log("By Complexity:");
-    for (const [complexity, count] of Object.entries(stats.byComplexity)) {
-      const pct = ((count / stats.total) * 100).toFixed(0);
-      this.log(`  ${complexity.padEnd(8)} ${String(count).padStart(3)} (${pct}%)`);
-    }
-    this.log("");
-
-    this.log("By Priority:");
-    for (const [priority, count] of Object.entries(stats.byPriority)) {
-      const pct = ((count / stats.total) * 100).toFixed(0);
-      this.log(`  ${priority.padEnd(12)} ${String(count).padStart(3)} (${pct}%)`);
-    }
-
-    return stats;
-  }
-}

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

@@ -1,113 +0,0 @@
-import { Flags } from "@oclif/core";
-import { createNgrokManager, getAgentStatus, isAgentRunning } from "../../../lib/ngrok.js";
-import { BaseCommand } from "../../base-command.js";
-
-export default class TunnelList extends BaseCommand {
-  static override description = "List active ngrok tunnels";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> tunnel list",
-    "<%= config.bin %> tunnel list --json",
-    "<%= config.bin %> tunnel list --urls",
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    urls: Flags.boolean({
-      char: "u",
-      description: "Output only URLs (one per line)",
-      default: false,
-    }),
-    status: Flags.boolean({
-      description: "Include agent status",
-      default: false,
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { flags } = await this.parse(TunnelList);
-    this.parsedFlags = flags;
-
-    const ngrok = createNgrokManager();
-
-    // Cleanup stale metadata
-    await ngrok.cleanup();
-
-    // Check if agent is running
-    const running = await isAgentRunning();
-    if (!running) {
-      if (flags.json || flags.format === "json") {
-        return { agent_running: false, tunnels: [] };
-      }
-      if (flags.urls) {
-        return { tunnels: [] };
-      }
-      this.logInfo("ngrok agent not running");
-      return { tunnels: [] };
-    }
-
-    const tunnels = await ngrok.list();
-    const agentStatus = flags.status ? await getAgentStatus() : undefined;
-
-    if (flags.json || flags.format === "json") {
-      return {
-        agent_running: true,
-        agent_status: agentStatus,
-        tunnels: tunnels.map((t) => ({
-          name: t.name,
-          public_url: t.public_url,
-          port: t.config?.addr,
-          session_id: t.metadata?.session_id,
-          created_at: t.metadata?.created_at,
-        })),
-      };
-    }
-
-    // NDJSON: one tunnel per line
-    if (this.ndjsonEnabled()) {
-      const items = tunnels.map((t) => ({
-        name: t.name,
-        public_url: t.public_url,
-        port: t.config?.addr,
-        session_id: t.metadata?.session_id,
-        created_at: t.metadata?.created_at,
-      }));
-      this.outputNdjson(items);
-      return { tunnels };
-    }
-
-    // URLs only (for piping)
-    if (flags.urls) {
-      for (const tunnel of tunnels) {
-        this.log(tunnel.public_url);
-      }
-      return { tunnels };
-    }
-
-    // Human-readable format
-    if (tunnels.length === 0) {
-      this.logInfo("No active tunnels");
-      return { tunnels: [] };
-    }
-
-    this.log("");
-    if (agentStatus) {
-      this.log(`Agent: v${agentStatus.version} (${agentStatus.region})`);
-      this.log("");
-    }
-
-    for (const tunnel of tunnels) {
-      this.log(`${tunnel.name}`);
-      this.log(`  url:     ${tunnel.public_url}`);
-      this.log(`  port:    ${tunnel.config?.addr || "unknown"}`);
-      if (tunnel.metadata) {
-        this.log(`  session: ${tunnel.metadata.session_id}`);
-        this.log(`  created: ${tunnel.metadata.created_at}`);
-      }
-      this.log("");
-    }
-
-    return { tunnels };
-  }
-}