@creativeintelligence/abbie 0.1.4 → 0.1.6

package/src/lib/triage.ts

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

@@ -1,61 +0,0 @@
-/**
- * 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

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