@creativeintelligence/abbie 0.1.0

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

@@ -0,0 +1,755 @@
+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)));
+}