@creativeintelligence/abbie 0.1.0

package/src/lib/triage.ts

@@ -0,0 +1,655 @@
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { AgentCapabilityType } from "./types.js";
+
+/**
+ * Issue type classification.
+ */
+export type IssueType = "bug" | "feature" | "refactor" | "improvement" | "chore" | "unknown";
+
+/**
+ * Complexity estimation.
+ */
+export type Complexity = "trivial" | "simple" | "medium" | "complex" | "epic";
+
+/**
+ * Agent capability match (includes 'human' for manual assignment).
+ */
+export type AgentCapability = AgentCapabilityType;
+
+/**
+ * Triage confidence level.
+ */
+export type TriageConfidence = "high" | "medium" | "low";
+
+/**
+ * Linear issue from API.
+ */
+export interface LinearIssue {
+  id: string;
+  identifier: string;
+  title: string;
+  description?: string;
+  priority: number;
+  priorityLabel: string;
+  estimate?: number;
+  state: {
+    id: string;
+    name: string;
+    type: string;
+  };
+  assignee?: {
+    id: string;
+    name: string;
+    displayName: string;
+  };
+  labels: {
+    nodes: Array<{
+      id: string;
+      name: string;
+    }>;
+  };
+  createdAt: string;
+  updatedAt: string;
+}
+
+/**
+ * Triaged issue with classification.
+ */
+export interface TriagedIssue {
+  issue: LinearIssue;
+  type: IssueType;
+  complexity: Complexity;
+  agent: AgentCapability;
+  confidence: TriageConfidence;
+  reason: string;
+  tags: string[];
+  queued_at?: string;
+}
+
+/**
+ * Triage queue stored on disk.
+ */
+export interface TriageQueue {
+  workspace: string;
+  team: string;
+  updated_at: string;
+  issues: TriagedIssue[];
+}
+
+/**
+ * Type classification patterns.
+ */
+const TYPE_PATTERNS: Record<IssueType, RegExp[]> = {
+  bug: [
+    /\bbug\b/i,
+    /\bfix\b/i,
+    /\bbroke\b/i,
+    /\bbroken\b/i,
+    /\bcrash/i,
+    /\berror\b/i,
+    /\bfail/i,
+    /\bregression/i,
+    /\bissue\b/i,
+    /\bdefect\b/i,
+    /doesn't work/i,
+    /not working/i,
+    /\bfunky\b/i,
+    /\bweird\b/i,
+    /\bwrong\b/i,
+    /\bglitch/i,
+    /\bflicker/i,
+  ],
+  feature: [
+    /\badd\b/i,
+    /\bnew\b/i,
+    /\bimplement\b/i,
+    /\bcreate\b/i,
+    /\bbuild\b/i,
+    /\bfeature\b/i,
+    /\bsupport\b/i,
+    /\benable\b/i,
+    /\bpinned\b/i,
+    /\bpin\b/i,
+    /\btab\b/i,
+    /\bwarning\b/i,
+    /\bprompt\b/i,
+    /\bconfirm/i,
+  ],
+  refactor: [
+    /\brefactor\b/i,
+    /\brestructure\b/i,
+    /\breorganize\b/i,
+    /\bcleanup\b/i,
+    /\bsimplify\b/i,
+    /\bmodernize\b/i,
+    /\bmigrate\b/i,
+  ],
+  improvement: [
+    /\bimprove\b/i,
+    /\benhance\b/i,
+    /\boptimize\b/i,
+    /\bupdate\b/i,
+    /\bupgrade\b/i,
+    /\bbetter\b/i,
+    /\baudit\b/i,
+    /\balign\b/i,
+    /\bux\b/i,
+    /\bui\b/i,
+    /\bstyling\b/i,
+    /\banimation/i,
+    /\bfeedback\b/i,
+  ],
+  chore: [
+    /\bchore\b/i,
+    /\bdeps\b/i,
+    /\bdependenc/i,
+    /\bbump\b/i,
+    /\bversion\b/i,
+    /\bci\b/i,
+    /\bcd\b/i,
+    /\btest\b/i,
+    /\bdocs?\b/i,
+  ],
+  unknown: [],
+};
+
+/**
+ * Complexity indicators.
+ */
+const COMPLEXITY_INDICATORS = {
+  trivial: {
+    words: ["typo", "copy", "text", "label", "rename", "simple"],
+    maxTitleWords: 5,
+  },
+  simple: {
+    words: ["small", "minor", "quick", "single", "one"],
+    maxTitleWords: 8,
+  },
+  medium: {
+    words: ["update", "change", "modify", "adjust"],
+    maxTitleWords: 12,
+  },
+  complex: {
+    words: ["integrate", "implement", "design", "architecture", "system"],
+    maxTitleWords: 20,
+  },
+  epic: {
+    words: ["epic", "major", "rewrite", "overhaul", "migrate", "platform"],
+    maxTitleWords: Infinity,
+  },
+};
+
+/**
+ * Agent capability mapping.
+ *
+ * Core agents: claude, codex, copilot, gemini
+ * Extended agents: opencode, droid, pi (experimental)
+ */
+const AGENT_CAPABILITY_MAP: Record<
+  AgentCapability,
+  { types: IssueType[]; maxComplexity: Complexity }
+> = {
+  // Core agents
+  copilot: {
+    types: ["bug", "chore", "improvement", "unknown"],
+    maxComplexity: "simple",
+  },
+  claude: {
+    types: ["bug", "feature", "improvement", "refactor", "chore", "unknown"],
+    maxComplexity: "medium",
+  },
+  codex: {
+    types: ["feature", "refactor", "improvement", "unknown"],
+    maxComplexity: "complex",
+  },
+  gemini: {
+    // Gemini is read-only exploration, not for implementation
+    types: ["unknown"],
+    maxComplexity: "trivial",
+  },
+  // Extended agents (experimental)
+  opencode: {
+    // OpenCode is multi-provider, similar capabilities to claude
+    types: ["bug", "feature", "improvement", "refactor", "chore", "unknown"],
+    maxComplexity: "medium",
+  },
+  droid: {
+    // Factory Droid is enterprise-grade, handles complex tasks
+    types: ["feature", "refactor", "improvement", "unknown"],
+    maxComplexity: "complex",
+  },
+  pi: {
+    // Pi is extensible, general-purpose
+    types: ["bug", "feature", "improvement", "refactor", "chore", "unknown"],
+    maxComplexity: "medium",
+  },
+  // Manual assignment
+  human: {
+    types: ["unknown"],
+    maxComplexity: "epic",
+  },
+};
+
+/**
+ * Complexity order for comparison.
+ */
+const COMPLEXITY_ORDER: Complexity[] = ["trivial", "simple", "medium", "complex", "epic"];
+
+/**
+ * Classify issue type from title and description.
+ */
+export function classifyType(
+  title: string,
+  description?: string,
+): { type: IssueType; confidence: TriageConfidence } {
+  const text = `${title} ${description || ""}`.toLowerCase();
+  const matches: { type: IssueType; count: number }[] = [];
+
+  for (const [type, patterns] of Object.entries(TYPE_PATTERNS)) {
+    if (type === "unknown") continue;
+    const count = patterns.filter((p) => p.test(text)).length;
+    if (count > 0) {
+      matches.push({ type: type as IssueType, count });
+    }
+  }
+
+  if (matches.length === 0) {
+    return { type: "unknown", confidence: "low" };
+  }
+
+  // Sort by match count
+  matches.sort((a, b) => b.count - a.count);
+
+  const best = matches[0];
+  const confidence: TriageConfidence =
+    best.count >= 3 ? "high" : best.count >= 2 ? "medium" : "low";
+
+  return { type: best.type, confidence };
+}
+
+/**
+ * Estimate issue complexity from title, description, and estimate.
+ */
+export function estimateComplexity(
+  title: string,
+  description?: string,
+  estimate?: number,
+): Complexity {
+  // If Linear estimate exists, use it
+  if (estimate !== undefined) {
+    if (estimate <= 1) return "trivial";
+    if (estimate <= 2) return "simple";
+    if (estimate <= 5) return "medium";
+    if (estimate <= 13) return "complex";
+    return "epic";
+  }
+
+  const text = `${title} ${description || ""}`.toLowerCase();
+  const titleWords = title.split(/\s+/).length;
+
+  // Check for complexity indicators
+  for (const [complexity, indicators] of Object.entries(COMPLEXITY_INDICATORS) as [
+    Complexity,
+    typeof COMPLEXITY_INDICATORS.trivial,
+  ][]) {
+    for (const word of indicators.words) {
+      if (text.includes(word)) {
+        return complexity;
+      }
+    }
+  }
+
+  // Fall back to title length heuristic
+  if (titleWords <= 5) return "trivial";
+  if (titleWords <= 8) return "simple";
+  if (titleWords <= 12) return "medium";
+  return "complex";
+}
+
+/**
+ * Compare complexity levels.
+ */
+function complexityLte(a: Complexity, b: Complexity): boolean {
+  return COMPLEXITY_ORDER.indexOf(a) <= COMPLEXITY_ORDER.indexOf(b);
+}
+
+/**
+ * Select best agent for issue.
+ */
+export function selectAgent(type: IssueType, complexity: Complexity): AgentCapability {
+  // Priority: copilot (fast) → claude (balanced) → codex (thorough) → human
+  const agents: AgentCapability[] = ["copilot", "claude", "codex", "human"];
+
+  for (const agent of agents) {
+    const caps = AGENT_CAPABILITY_MAP[agent];
+    if (caps.types.includes(type) && complexityLte(complexity, caps.maxComplexity)) {
+      return agent;
+    }
+  }
+
+  return "human";
+}
+
+/**
+ * Extract tags from issue labels.
+ */
+export function extractTags(issue: LinearIssue): string[] {
+  const tags: string[] = [];
+
+  // Add labels
+  for (const label of issue.labels.nodes) {
+    tags.push(label.name.toLowerCase());
+  }
+
+  // Add priority tag
+  if (issue.priority <= 1) {
+    tags.push("urgent");
+  } else if (issue.priority === 2) {
+    tags.push("high-priority");
+  }
+
+  // Add state tag
+  tags.push(issue.state.type);
+
+  return [...new Set(tags)];
+}
+
+/**
+ * Triage a single issue.
+ */
+export function triageIssue(issue: LinearIssue): TriagedIssue {
+  const { type, confidence: typeConfidence } = classifyType(issue.title, issue.description);
+  const complexity = estimateComplexity(
+    issue.title,
+    issue.description,
+    issue.estimate ?? undefined,
+  );
+  const agent = selectAgent(type, complexity);
+  const tags = extractTags(issue);
+
+  // Build reason
+  const reasons: string[] = [];
+  reasons.push(`type=${type}`);
+  reasons.push(`complexity=${complexity}`);
+  if (issue.estimate) {
+    reasons.push(`estimate=${issue.estimate}`);
+  }
+  if (tags.includes("urgent")) {
+    reasons.push("urgent");
+  }
+
+  // Overall confidence
+  let confidence: TriageConfidence = typeConfidence;
+  if (type === "unknown" || complexity === "epic") {
+    confidence = "low";
+  }
+
+  return {
+    issue,
+    type,
+    complexity,
+    agent,
+    confidence,
+    reason: reasons.join(", "),
+    tags,
+  };
+}
+
+/**
+ * Pull issues from Linear workspace.
+ */
+export function pullIssues(options: {
+  workspace: string;
+  team: string;
+  assignee?: string;
+  state?: string[];
+  limit?: number;
+}): LinearIssue[] {
+  const args = [
+    "issue",
+    "list",
+    "--team",
+    options.team,
+    "--workspace",
+    options.workspace,
+    "--json",
+  ];
+
+  if (options.assignee) {
+    args.push("--assignee", options.assignee);
+  }
+
+  if (options.state && options.state.length > 0) {
+    for (const s of options.state) {
+      args.push("--state", s);
+    }
+  }
+
+  args.push("--limit", String(options.limit || 50));
+
+  try {
+    const result = execSync(`linear ${args.join(" ")}`, {
+      encoding: "utf-8",
+      maxBuffer: 10 * 1024 * 1024,
+    });
+    return JSON.parse(result) as LinearIssue[];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Triage queue manager.
+ */
+export class TriageQueueManager {
+  private basePath: string;
+
+  constructor(basePath: string = "~/.abbie/triage") {
+    this.basePath = basePath.replace("~", homedir());
+    if (!existsSync(this.basePath)) {
+      mkdirSync(this.basePath, { recursive: true });
+    }
+  }
+
+  /**
+   * Get queue file path.
+   */
+  private getQueuePath(workspace: string, team: string): string {
+    return join(this.basePath, `${workspace}-${team}.json`);
+  }
+
+  /**
+   * Load queue from disk.
+   */
+  load(workspace: string, team: string): TriageQueue | undefined {
+    const path = this.getQueuePath(workspace, team);
+    if (!existsSync(path)) return undefined;
+    return JSON.parse(readFileSync(path, "utf-8")) as TriageQueue;
+  }
+
+  /**
+   * Save queue to disk.
+   */
+  save(queue: TriageQueue): void {
+    const path = this.getQueuePath(queue.workspace, queue.team);
+    writeFileSync(path, JSON.stringify(queue, null, 2));
+  }
+
+  /**
+   * Pull and triage issues from Linear.
+   */
+  refresh(options: {
+    workspace: string;
+    team: string;
+    assignee?: string;
+    states?: string[];
+    limit?: number;
+  }): TriageQueue {
+    const issues = pullIssues({
+      workspace: options.workspace,
+      team: options.team,
+      assignee: options.assignee,
+      state: options.states,
+      limit: options.limit,
+    });
+
+    const triaged = issues.map(triageIssue);
+
+    // Sort by priority: urgent first, then by confidence, then by complexity
+    triaged.sort((a, b) => {
+      // Urgent first
+      const aUrgent = a.tags.includes("urgent") ? 0 : 1;
+      const bUrgent = b.tags.includes("urgent") ? 0 : 1;
+      if (aUrgent !== bUrgent) return aUrgent - bUrgent;
+
+      // High confidence first
+      const confOrder = { high: 0, medium: 1, low: 2 };
+      if (confOrder[a.confidence] !== confOrder[b.confidence]) {
+        return confOrder[a.confidence] - confOrder[b.confidence];
+      }
+
+      // Lower complexity first (easier to automate)
+      return COMPLEXITY_ORDER.indexOf(a.complexity) - COMPLEXITY_ORDER.indexOf(b.complexity);
+    });
+
+    const queue: TriageQueue = {
+      workspace: options.workspace,
+      team: options.team,
+      updated_at: new Date().toISOString(),
+      issues: triaged,
+    };
+
+    this.save(queue);
+    return queue;
+  }
+
+  /**
+   * Get next issue for an agent.
+   */
+  next(workspace: string, team: string, agent: AgentCapability): TriagedIssue | undefined {
+    const queue = this.load(workspace, team);
+    if (!queue) return undefined;
+
+    // Find first unqueued issue matching agent capability
+    return queue.issues.find(
+      (i) => i.agent === agent && !i.queued_at && i.issue.state.type !== "completed",
+    );
+  }
+
+  /**
+   * Mark issue as queued.
+   */
+  markQueued(workspace: string, team: string, identifier: string): void {
+    const queue = this.load(workspace, team);
+    if (!queue) return;
+
+    const issue = queue.issues.find((i) => i.issue.identifier === identifier);
+    if (issue) {
+      issue.queued_at = new Date().toISOString();
+      this.save(queue);
+    }
+  }
+
+  /**
+   * Get queue statistics.
+   */
+  stats(
+    workspace: string,
+    team: string,
+  ):
+    | {
+        total: number;
+        byType: Record<IssueType, number>;
+        byAgent: Record<AgentCapability, number>;
+        byComplexity: Record<Complexity, number>;
+        byPriority: Record<string, number>;
+        queued: number;
+        pending: number;
+      }
+    | undefined {
+    const queue = this.load(workspace, team);
+    if (!queue) return undefined;
+
+    const stats = {
+      total: queue.issues.length,
+      byType: {} as Record<IssueType, number>,
+      byAgent: {} as Record<AgentCapability, number>,
+      byComplexity: {} as Record<Complexity, number>,
+      byPriority: {} as Record<string, number>,
+      queued: 0,
+      pending: 0,
+    };
+
+    for (const issue of queue.issues) {
+      stats.byType[issue.type] = (stats.byType[issue.type] || 0) + 1;
+      stats.byAgent[issue.agent] = (stats.byAgent[issue.agent] || 0) + 1;
+      stats.byComplexity[issue.complexity] = (stats.byComplexity[issue.complexity] || 0) + 1;
+      const priority = issue.issue.priorityLabel || "No Priority";
+      stats.byPriority[priority] = (stats.byPriority[priority] || 0) + 1;
+
+      if (issue.queued_at) {
+        stats.queued++;
+      } else {
+        stats.pending++;
+      }
+    }
+
+    return stats;
+  }
+}
+
+/**
+ * Create a triage queue manager with default path.
+ */
+export function createTriageManager(): TriageQueueManager {
+  return new TriageQueueManager();
+}
+
+// Unix pipe helpers
+
+/**
+ * Print triaged issues to stdout.
+ * Usage: abbie triage pull --team ZO | jq '.issues[].issue.identifier'
+ */
+export function printTriageQueue(queue: TriageQueue, format: "json" | "text" = "json"): void {
+  if (format === "json") {
+    process.stdout.write(`${JSON.stringify(queue, null, 2)}\n`);
+  } else {
+    for (const issue of queue.issues) {
+      const line = `${issue.issue.identifier}\t${issue.type}\t${issue.complexity}\t${issue.agent}\t${issue.issue.title}`;
+      process.stdout.write(`${line}\n`);
+    }
+  }
+}
+
+/**
+ * Print issue identifiers to stdout (for piping).
+ * Usage: abbie triage next --agent claude | xargs -I{} linear issue view {}
+ */
+export function printIdentifiers(issues: TriagedIssue[]): void {
+  for (const issue of issues) {
+    process.stdout.write(`${issue.issue.identifier}\n`);
+  }
+}
+
+/**
+ * Fetch Linear issues (async-compatible alias for pullIssues).
+ */
+export async function fetchLinearIssues(options: {
+  workspace: string;
+  team: string;
+  assignee?: string;
+  states?: string[];
+  limit?: number;
+}): Promise<LinearIssue[]> {
+  return pullIssues({
+    workspace: options.workspace,
+    team: options.team,
+    assignee: options.assignee,
+    state: options.states,
+    limit: options.limit,
+  });
+}

package/src/lib/types.ts

@@ -0,0 +1,61 @@
+/**
+ * Shared types for the abbie CLI
+ */
+
+/**
+ * Supported agent platforms
+ *
+ * Core agents (fully integrated):
+ * - claude: Anthropic Claude Code CLI
+ * - codex: OpenAI Codex CLI
+ * - copilot: GitHub Copilot CLI
+ * - gemini: Google Gemini CLI
+ *
+ * Extended agents (experimental):
+ * - opencode: SST's opencode CLI (Go, multi-provider)
+ * - droid: Factory AI's Droid CLI (enterprise, multi-model)
+ * - pi: Pi coding agent (TypeScript, extensible)
+ */
+export const Agent = {
+  // Core agents
+  CLAUDE: "claude",
+  CODEX: "codex",
+  COPILOT: "copilot",
+  GEMINI: "gemini",
+  // Extended agents
+  OPENCODE: "opencode",
+  DROID: "droid",
+  PI: "pi",
+} as const;
+
+export type AgentType = (typeof Agent)[keyof typeof Agent];
+
+/**
+ * All valid agent values as an array (for validation)
+ */
+export const AGENTS = Object.values(Agent) as AgentType[];
+
+/**
+ * Check if a string is a valid agent type
+ */
+export function isValidAgent(value: string): value is AgentType {
+  return AGENTS.includes(value as AgentType);
+}
+
+/**
+ * Agent capabilities for triage/assignment
+ * Note: 'human' is included for manual assignment
+ */
+export const AgentCapability = {
+  ...Agent,
+  HUMAN: "human",
+} as const;
+
+export type AgentCapabilityType = (typeof AgentCapability)[keyof typeof AgentCapability];
+
+export const AGENT_CAPABILITIES = Object.values(AgentCapability) as AgentCapabilityType[];
+
+/**
+ * Default agent when none specified
+ */
+export const DEFAULT_AGENT: AgentType = Agent.CLAUDE;

package/src/lib/windows/index.ts

@@ -0,0 +1,2 @@
+export * from "./inventory.js";
+export * from "./types.js";