@creativeintelligence/abbie 0.1.4 → 0.1.5

package/src/cli/commands/auto/index.ts

@@ -1,755 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { Flags } from "@oclif/core";
-import {
-  type DiscoveryReport,
-  type DiscoveryResult,
-  discoverWork,
-  type WorkItem,
-} from "../../../lib/auto/discover.js";
-import { ideatedToWorkItem, ideateWork } from "../../../lib/auto/ideate.js";
-import { decideAgent, type SpawnResult, spawnWorkItems } from "../../../lib/auto/spawn.js";
-import { resolveLinearApiKeyAsync } from "../../../lib/auto/workspace.js";
-import { createEvent, EventStore, generateSessionId } from "../../../lib/events.js";
-import { HeartbeatManager } from "../../../lib/heartbeat.js";
-import { createResourceManager } from "../../../lib/resources.js";
-import { getTrackedIssues } from "../../../lib/triage-tracker.js";
-import { BaseCommand } from "../../base-command.js";
-
-type SlackStatus = {
-  status: "sent" | "skipped" | "failed";
-  detail?: string;
-};
-
-type AutoResult = {
-  session_id: string;
-  project: string;
-  dry_run: boolean;
-  discovery: DiscoveryResult;
-  spawn: SpawnResult[];
-  slack: SlackStatus;
-  started_at: string;
-  completed_at: string;
-};
-
-export default class AutoCommand extends BaseCommand {
-  static override summary = "Auto-discover work and spawn agents";
-  static override description =
-    "Discovers work from Linear, CLAUDE.md TODOs, and git staleness, then coordinates agent execution.";
-
-  static override examples = [
-    "<%= config.bin %> auto",
-    "<%= config.bin %> auto --dry-run",
-    "<%= config.bin %> auto --project agents --limit 3",
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    project: Flags.string({
-      char: "p",
-      description: "Project name (defaults to current working directory)",
-    }),
-    "dry-run": Flags.boolean({
-      description: "Discover work without spawning agents or posting to Slack",
-      default: false,
-    }),
-    limit: Flags.integer({
-      char: "l",
-      description: "Limit total work items processed",
-      default: 5,
-    }),
-    "stale-days": Flags.integer({
-      description: "Git staleness threshold in days",
-      default: 14,
-    }),
-    linear: Flags.boolean({
-      description: "Include Linear discovery",
-      default: true,
-      allowNo: true,
-    }),
-    "linear-cache": Flags.string({
-      description: "Path to Linear issues JSON cache",
-    }),
-    slack: Flags.boolean({
-      description: "Post coordination updates to Slack",
-      default: true,
-      allowNo: true,
-    }),
-    "slack-channel": Flags.string({
-      description: "Slack channel name",
-      default: "agents",
-    }),
-    "slack-agent": Flags.string({
-      description: "Slack agent name",
-      default: "auto",
-    }),
-    "slack-workspace": Flags.string({
-      description: "Slack workspace (optional)",
-    }),
-    spawn: Flags.boolean({
-      description: "Spawn agent processes",
-      default: true,
-      allowNo: true,
-    }),
-    triage: Flags.boolean({
-      description: "Use triage-based discovery for smarter classification",
-      default: false,
-    }),
-    "triage-workspace": Flags.string({
-      description: "Linear workspace for triage (e.g., zocomputer)",
-    }),
-    "triage-team": Flags.string({
-      description: "Linear team for triage (e.g., ZO)",
-    }),
-    "triage-assignee": Flags.string({
-      description: "Filter by assignee for triage",
-    }),
-    ideate: Flags.boolean({
-      description:
-        "Use LLM-based ideation to discover new work from git trajectory and codebase analysis",
-      default: false,
-    }),
-    "ideate-paths": Flags.string({
-      description: "Comma-separated paths to analyze for ideation (default: auto-detect)",
-    }),
-    "ideate-days": Flags.integer({
-      description: "Days of git history to analyze",
-      default: 14,
-    }),
-    preview: Flags.boolean({
-      description:
-        "Enable preview funnel: spawn agents in isolated git worktrees with live preview URLs via ngrok",
-      default: false,
-    }),
-    "preview-port": Flags.integer({
-      description: "Base port for preview dev servers (increments for each spawn)",
-      default: 3100,
-    }),
-    "preview-cmd": Flags.string({
-      description: "Command to start dev server for preview",
-      default: "pnpm dev",
-    }),
-  };
-
-  protected async execute(): Promise<AutoResult> {
-    const { flags } = await this.parse(AutoCommand);
-    this.parsedFlags = flags;
-
-    const cwd = process.cwd();
-    const project = flags.project || resolveProjectFromCwd(cwd);
-    if (!project) {
-      this.error("Unable to determine project name. Use --project to set one.");
-    }
-
-    const dryRun = flags["dry-run"];
-    const sessionId = generateSessionId(project);
-    const startedAt = new Date().toISOString();
-
-    const stateDir = resolveStateDir(cwd, dryRun);
-    const eventStore = new EventStore(stateDir ? join(stateDir, "events") : undefined);
-    const heartbeat = new HeartbeatManager(
-      stateDir ? join(stateDir, "sessions") : undefined,
-      {},
-      eventStore,
-    );
-    const resources = createResourceManager(
-      stateDir ? join(stateDir, "resources") : undefined,
-      eventStore,
-    );
-    const configPath = join(cwd, ".loop.json");
-
-    resources.loadConfig(configPath);
-
-    let currentTask: string | undefined;
-
-    heartbeat.register(sessionId, "auto", {
-      project,
-      worktree: cwd,
-      pid: process.pid,
-    });
-    heartbeat.startAutoHeartbeat(sessionId, () => currentTask);
-
-    eventStore.append(
-      createEvent.sessionStart(sessionId, "auto", {
-        project,
-        worktree: cwd,
-        config_path: existsSync(configPath) ? configPath : undefined,
-      }),
-    );
-
-    let discovery: DiscoveryResult = { items: [], sources: [] };
-    let spawnResults: SpawnResult[] = [];
-    let slackStatus: SlackStatus = { status: "skipped", detail: "not attempted" };
-
-    try {
-      // Resolve Linear API key based on workspace (validates and finds correct key)
-      const workspaceResolution = await resolveLinearApiKeyAsync(cwd);
-      if (workspaceResolution.warning && !flags.quiet) {
-        this.warn(workspaceResolution.warning);
-      }
-
-      // Use ideation-based discovery if enabled
-      if (flags.ideate) {
-        discovery = await discoverWithIdeation({
-          cwd,
-          project,
-          paths: flags["ideate-paths"]?.split(",") || detectProjectPaths(cwd),
-          limit: flags.limit,
-          commitDays: flags["ideate-days"] ?? 14,
-          dryRun,
-        });
-      } else if (flags.triage && flags["triage-workspace"] && flags["triage-team"]) {
-        // Use triage-based discovery if enabled
-        discovery = await discoverWithTriage({
-          workspace: flags["triage-workspace"],
-          team: flags["triage-team"],
-          assignee: flags["triage-assignee"],
-          limit: flags.limit,
-          cwd,
-          staleDays: flags["stale-days"],
-        });
-      } else {
-        discovery = await discoverWork({
-          cwd,
-          project,
-          dryRun,
-          limit: flags.limit,
-          staleDays: flags["stale-days"],
-          linear: {
-            enabled: flags.linear,
-            apiKey: workspaceResolution.apiKey,
-            apiUrl: process.env.LINEAR_API_URL,
-            limit: flags.limit,
-            cachePath: flags["linear-cache"],
-            project,
-            team: workspaceResolution.team,
-          },
-          resources,
-          sessionId,
-        });
-      }
-
-      if (discovery.items.length === 0) {
-        slackStatus = await maybePostSlack(
-          {
-            sessionId,
-            project,
-            dryRun,
-            discovery,
-            spawn: [],
-            startedAt,
-            completedAt: new Date().toISOString(),
-          },
-          flags,
-          resources,
-        );
-        recordSlackEvent(eventStore, sessionId, slackStatus, flags);
-
-        eventStore.append(
-          createEvent.complete(sessionId, "auto", {
-            summary: "No work discovered",
-            artifacts: [],
-            duration_ms: Date.now() - new Date(startedAt).getTime(),
-          }),
-        );
-
-        const result: AutoResult = {
-          session_id: sessionId,
-          project,
-          dry_run: dryRun,
-          discovery,
-          spawn: [],
-          slack: slackStatus,
-          started_at: startedAt,
-          completed_at: new Date().toISOString(),
-        };
-
-        if (!this.jsonEnabled?.()) {
-          this.logSummary(result);
-        }
-
-        return result;
-      }
-
-      currentTask = "spawning agents";
-
-      for (const item of discovery.items) {
-        eventStore.append(
-          createEvent.taskStart(sessionId, "auto", {
-            task_id: item.id,
-            description: item.title,
-            issue: item.issue,
-          }),
-        );
-      }
-
-      spawnResults = flags.spawn
-        ? await spawnWorkItems(discovery.items, {
-            dryRun,
-            cwd,
-            project,
-            sessionId,
-            resources,
-            max: flags.limit,
-            preview: flags.preview
-              ? {
-                  enabled: true,
-                  basePort: flags["preview-port"],
-                  devCommand: flags["preview-cmd"],
-                }
-              : undefined,
-          })
-        : discovery.items.map((item) => {
-            const request = decideAgent(item);
-            return {
-              request,
-              status: "planned" as const,
-              message: "spawn disabled",
-            };
-          });
-
-      for (const result of spawnResults) {
-        if (result.status === "blocked") {
-          eventStore.append(
-            createEvent.blocked(sessionId, "auto", {
-              reason: result.message || "resource contention",
-              blocker_type: "resource",
-              context: {
-                task_id: result.request.work.id,
-                agent: result.request.agent,
-              },
-            }),
-          );
-          continue;
-        }
-
-        eventStore.append(
-          createEvent.taskComplete(sessionId, "auto", {
-            task_id: result.request.work.id,
-            summary: result.message || "spawn planned",
-            confidence: result.status === "spawned" ? 0.7 : 0.4,
-          }),
-        );
-      }
-
-      slackStatus = await maybePostSlack(
-        {
-          sessionId,
-          project,
-          dryRun,
-          discovery,
-          spawn: spawnResults,
-          startedAt,
-          completedAt: new Date().toISOString(),
-        },
-        flags,
-        resources,
-      );
-      recordSlackEvent(eventStore, sessionId, slackStatus, flags);
-
-      eventStore.append(
-        createEvent.complete(sessionId, "auto", {
-          summary: `Processed ${spawnResults.length} work item(s)`,
-          artifacts: [],
-          duration_ms: Date.now() - new Date(startedAt).getTime(),
-        }),
-      );
-    } catch (err) {
-      eventStore.append({
-        type: "session:failed",
-        session_id: sessionId,
-        agent: "auto",
-        data: {
-          reason: (err as Error).message,
-        },
-      });
-      throw err;
-    } finally {
-      currentTask = undefined;
-      heartbeat.stopAutoHeartbeat();
-      heartbeat.deregister(sessionId);
-    }
-
-    const completedAt = new Date().toISOString();
-    const result: AutoResult = {
-      session_id: sessionId,
-      project,
-      dry_run: dryRun,
-      discovery,
-      spawn: spawnResults,
-      slack: slackStatus,
-      started_at: startedAt,
-      completed_at: completedAt,
-    };
-
-    if (!this.jsonEnabled?.()) {
-      this.logSummary(result);
-    }
-
-    return result;
-  }
-
-  private logSummary(result: AutoResult): void {
-    this.log(`Session: ${result.session_id}`);
-    this.log(`Project: ${result.project}`);
-    this.log(`Dry run: ${result.dry_run ? "yes" : "no"}`);
-    this.log("");
-
-    this.log(`Discovered: ${result.discovery.items.length} item(s)`);
-    for (const source of result.discovery.sources) {
-      this.log(formatSourceSummary(source));
-    }
-
-    this.log("");
-    this.log(`Spawn results: ${result.spawn.length} item(s)`);
-    for (const spawn of result.spawn) {
-      const title = spawn.request.work.title;
-      const previewUrl = spawn.preview?.tunnelUrl ? ` → ${spawn.preview.tunnelUrl}` : "";
-      this.log(`- ${spawn.status} ${spawn.request.agent}: ${title}${previewUrl}`);
-    }
-
-    this.log("");
-    this.log(
-      `Slack: ${result.slack.status}${result.slack.detail ? ` (${result.slack.detail})` : ""}`,
-    );
-    this.log("");
-  }
-}
-
-function resolveProjectFromCwd(cwd: string): string | undefined {
-  const parts = cwd.split("/").filter(Boolean);
-  const devIndex = parts.lastIndexOf("Developer");
-  if (devIndex !== -1 && parts.length > devIndex + 2) {
-    return parts[devIndex + 2];
-  }
-  return parts[parts.length - 1];
-}
-
-function resolveStateDir(cwd: string, dryRun: boolean): string | undefined {
-  const envDir = process.env.AGENTS_STATE_DIR || process.env.AUTO_STATE_DIR;
-  if (envDir) {
-    return expandHome(envDir);
-  }
-
-  if (dryRun) {
-    return join(cwd, ".abbie");
-  }
-
-  return undefined;
-}
-
-function expandHome(path: string): string {
-  if (path.startsWith("~")) {
-    return path.replace("~", process.env.HOME || "");
-  }
-  return path;
-}
-
-function formatSourceSummary(source: DiscoveryReport): string {
-  const detail = source.detail ? ` (${source.detail})` : "";
-  return `- ${source.source}: ${source.status}, ${source.items} item(s)${detail}`;
-}
-
-function recordSlackEvent(
-  eventStore: EventStore,
-  sessionId: string,
-  status: SlackStatus,
-  flags: Record<string, unknown>,
-): void {
-  if (status.status === "skipped") return;
-  const channel = typeof flags["slack-channel"] === "string" ? flags["slack-channel"] : undefined;
-  eventStore.append({
-    type: "notification:sent",
-    session_id: sessionId,
-    agent: "auto",
-    data: {
-      channel,
-      status: status.status,
-      detail: status.detail,
-    },
-  });
-}
-
-async function maybePostSlack(
-  payload: {
-    sessionId: string;
-    project: string;
-    dryRun: boolean;
-    discovery: DiscoveryResult;
-    spawn: SpawnResult[];
-    startedAt: string;
-    completedAt: string;
-  },
-  flags: Record<string, unknown>,
-  resources: ReturnType<typeof createResourceManager>,
-): Promise<SlackStatus> {
-  if (flags.slack !== true || payload.dryRun) {
-    return { status: "skipped", detail: payload.dryRun ? "dry-run" : "disabled" };
-  }
-
-  if (!isCommandAvailable("slack")) {
-    return { status: "skipped", detail: "slack cli not available" };
-  }
-
-  const lease = resources.acquire("slack_api", payload.sessionId, "auto");
-  if (!lease) {
-    return { status: "skipped", detail: "slack resource at capacity" };
-  }
-
-  const message = formatYaml({
-    event: "agents.auto",
-    session_id: payload.sessionId,
-    project: payload.project,
-    dry_run: payload.dryRun,
-    started_at: payload.startedAt,
-    completed_at: payload.completedAt,
-    discovery: {
-      total: payload.discovery.items.length,
-      sources: payload.discovery.sources,
-    },
-    spawn: payload.spawn.map((result) => ({
-      id: result.request.work.id,
-      title: result.request.work.title,
-      source: result.request.work.source,
-      agent: result.request.agent,
-      effort: result.request.effort,
-      status: result.status,
-      issue: result.request.work.issue,
-      url: result.request.work.url,
-      preview: result.preview?.tunnelUrl,
-    })),
-  });
-
-  const slackAgent =
-    typeof flags["slack-agent"] === "string" && flags["slack-agent"]
-      ? flags["slack-agent"]
-      : "auto";
-  const slackChannel =
-    typeof flags["slack-channel"] === "string" && flags["slack-channel"]
-      ? flags["slack-channel"]
-      : "agents";
-
-  const args = [
-    "agent",
-    "post",
-    "--agent",
-    slackAgent,
-    "--channel",
-    slackChannel,
-    "--text",
-    message,
-  ];
-
-  const workspace =
-    typeof flags["slack-workspace"] === "string"
-      ? flags["slack-workspace"]
-      : process.env.SLACK_WORKSPACE;
-  if (workspace) {
-    args.push("-w", workspace);
-  }
-
-  const result = spawnSync("slack", args, { stdio: "ignore" });
-  resources.release("slack_api", payload.sessionId);
-
-  if (result.status === 0) {
-    return { status: "sent" };
-  }
-
-  return { status: "failed", detail: `exit ${result.status ?? "unknown"}` };
-}
-
-function isCommandAvailable(command: string): boolean {
-  const result = spawnSync("which", [command], { stdio: "ignore" });
-  return result.status === 0;
-}
-
-function formatYaml(value: unknown, indent = 0): string {
-  const pad = "  ".repeat(indent);
-  if (Array.isArray(value)) {
-    if (value.length === 0) return `${pad}[]`;
-    return value
-      .map((item) => {
-        if (isScalar(item)) {
-          return `${pad}- ${formatScalar(item)}`;
-        }
-        return `${pad}-\n${formatYaml(item, indent + 1)}`;
-      })
-      .join("\n");
-  }
-
-  if (value && typeof value === "object") {
-    const entries = Object.entries(value as Record<string, unknown>);
-    if (entries.length === 0) return `${pad}{}`;
-    return entries
-      .map(([key, val]) => {
-        if (isScalar(val)) {
-          return `${pad}${key}: ${formatScalar(val)}`;
-        }
-        return `${pad}${key}:\n${formatYaml(val, indent + 1)}`;
-      })
-      .join("\n");
-  }
-
-  return `${pad}${formatScalar(value)}`;
-}
-
-function isScalar(value: unknown): boolean {
-  return (
-    value === null || value === undefined || ["string", "number", "boolean"].includes(typeof value)
-  );
-}
-
-function formatScalar(value: unknown): string {
-  if (value === null || value === undefined) return "null";
-  if (typeof value === "number" || typeof value === "boolean") return String(value);
-
-  const str = String(value);
-  if (str === "") return '""';
-  if (/[:#\n]/.test(str) || /^\s|\s$/.test(str)) {
-    return `"${str.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
-  }
-  return str;
-}
-
-/**
- * Discover work using the LLM-based tracking registry for smarter classification.
- * Pulls from luke-labs tracking workspace and sorts by confidence (impact-first).
- */
-async function discoverWithTriage(options: {
-  workspace: string;
-  team: string;
-  assignee?: string;
-  limit: number;
-  cwd: string;
-  staleDays: number;
-}): Promise<DiscoveryResult> {
-  // Get tracked issues from registry
-  const tracked = getTrackedIssues();
-
-  // Filter by workspace/team and status
-  const eligible = tracked.filter((t) => {
-    // Only issues from the requested tracking workspace
-    if (t.tracking_workspace !== options.workspace) return false;
-    if (t.tracking_team !== options.team) return false;
-    // Only pending or claimed (not in_progress, blocked, or done)
-    if (!["pending", "claimed"].includes(t.status)) return false;
-    return true;
-  });
-
-  // Sort by confidence (high → low) for impact-first selection
-  const sorted = eligible.sort((a, b) => {
-    const confA = a.classification.confidence;
-    const confB = b.classification.confidence;
-    // Higher confidence first
-    if (confB !== confA) return confB - confA;
-    // Then by complexity (medium/complex over trivial/simple for impact)
-    const complexityOrder: Record<string, number> = {
-      epic: 4,
-      complex: 3,
-      medium: 2,
-      simple: 1,
-      trivial: 0,
-    };
-    return (
-      (complexityOrder[b.classification.complexity] || 0) -
-      (complexityOrder[a.classification.complexity] || 0)
-    );
-  });
-
-  // Map to work items
-  const items: WorkItem[] = sorted.slice(0, options.limit).map((t) => ({
-    id: `linear-${t.tracking_identifier}`,
-    source: "linear",
-    title: `[${t.classification.agent}] ${t.source_identifier}: ${t.source_title}`,
-    details: t.classification.suggested_prompt,
-    issue: t.tracking_identifier,
-    url: t.tracking_url,
-    priority: 0,
-    effort:
-      t.classification.complexity === "trivial" || t.classification.complexity === "simple"
-        ? "quick"
-        : "thorough",
-    metadata: {
-      type: t.classification.type,
-      complexity: t.classification.complexity,
-      agent: t.classification.agent,
-      confidence: mapConfidenceToLabel(t.classification.confidence),
-      tags: t.classification.tags,
-      source_identifier: t.source_identifier,
-      source_url: t.source_url,
-    },
-  }));
-
-  const sources: DiscoveryReport[] = [
-    {
-      source: "linear",
-      status: "ok",
-      detail: `triage: ${options.workspace}/${options.team}`,
-      items: items.length,
-    },
-  ];
-
-  return { items, sources };
-}
-
-/**
- * Map numeric confidence (1-10) to label.
- */
-function mapConfidenceToLabel(confidence: number): string {
-  if (confidence >= 8) return "high";
-  if (confidence >= 5) return "medium";
-  return "low";
-}
-
-/**
- * Discover work using LLM-based ideation from git trajectory and codebase analysis.
- * Analyzes recent commits and codebase to generate new work items.
- */
-async function discoverWithIdeation(options: {
-  cwd: string;
-  project: string;
-  paths: string[];
-  limit: number;
-  commitDays: number;
-  dryRun: boolean;
-}): Promise<DiscoveryResult> {
-  const ideation = await ideateWork({
-    cwd: options.cwd,
-    paths: options.paths,
-    limit: options.limit,
-    commitDays: options.commitDays,
-    dryRun: options.dryRun,
-  });
-
-  const items: WorkItem[] = ideation.ideated_work.map((work, i) => ideatedToWorkItem(work, i));
-
-  const sources: DiscoveryReport[] = [
-    {
-      source: "claude",
-      status: "ok",
-      detail: `ideation: ${ideation.git_signals.length} git signals, ${ideation.codebase_signals.length} codebase signals`,
-      items: items.length,
-    },
-  ];
-
-  return { items, sources };
-}
-
-/**
- * Detect project paths based on cwd structure.
- * Returns common TypeScript package paths for monorepos.
- */
-function detectProjectPaths(cwd: string): string[] {
-  const common = [
-    "ts-packages/web",
-    "ts-packages/www",
-    "packages/web",
-    "packages/www",
-    "apps/web",
-    "apps/www",
-    "src",
-  ];
-
-  return common.filter((p) => existsSync(join(cwd, p)));
-}