@creativeintelligence/abbie 0.1.4 → 0.1.5

package/src/lib/auto/discover.ts

@@ -1,545 +0,0 @@
-import { execSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import type { ResourceManager } from "../resources.js";
-
-export type WorkSource = "linear" | "claude" | "git";
-
-export interface WorkItem {
-  id: string;
-  source: WorkSource;
-  title: string;
-  details?: string;
-  issue?: string;
-  url?: string;
-  project?: string;
-  priority?: number;
-  effort?: "quick" | "thorough";
-  metadata?: Record<string, unknown>;
-}
-
-export interface DiscoveryReport {
-  source: WorkSource;
-  status: "ok" | "skipped" | "error";
-  detail?: string;
-  items: number;
-}
-
-export interface DiscoveryResult {
-  items: WorkItem[];
-  sources: DiscoveryReport[];
-}
-
-export interface LinearDiscoveryOptions {
-  enabled: boolean;
-  apiKey?: string;
-  apiUrl?: string;
-  limit: number;
-  cachePath?: string;
-  project?: string;
-  team?: string;
-}
-
-export interface DiscoveryOptions {
-  cwd: string;
-  project?: string;
-  dryRun: boolean;
-  limit: number;
-  staleDays: number;
-  linear: LinearDiscoveryOptions;
-  resources?: ResourceManager;
-  sessionId?: string;
-}
-
-type LinearIssue = {
-  id?: string;
-  identifier?: string;
-  title?: string;
-  description?: string;
-  url?: string;
-  priority?: number;
-  project?: { name?: string };
-  state?: { name?: string; type?: string };
-};
-
-export async function discoverWork(options: DiscoveryOptions): Promise<DiscoveryResult> {
-  const sources: DiscoveryReport[] = [];
-
-  const linear = await discoverLinearWork(options);
-  sources.push(linear.report);
-
-  const claude = discoverClaudeTodos(options.cwd);
-  sources.push(claude.report);
-
-  const git = discoverGitStaleness(options.cwd, options.staleDays);
-  sources.push(git.report);
-
-  const combined =
-    options.limit > 0
-      ? interleave([linear.items, claude.items, git.items], options.limit)
-      : [...linear.items, ...claude.items, ...git.items];
-
-  const limited = combined;
-  return { items: limited, sources };
-}
-
-function interleave(items: WorkItem[][], limit: number): WorkItem[] {
-  const result: WorkItem[] = [];
-  let index = 0;
-
-  while (result.length < limit && items.some((bucket) => index < bucket.length)) {
-    for (const bucket of items) {
-      if (index < bucket.length) {
-        result.push(bucket[index]);
-        if (result.length >= limit) break;
-      }
-    }
-    index++;
-  }
-
-  return result;
-}
-
-function discoverClaudeTodos(cwd: string): { items: WorkItem[]; report: DiscoveryReport } {
-  const files = ["CLAUDE.md", "AGENTS.md"];
-  const items: WorkItem[] = [];
-  const seen = new Set<string>();
-  let scanned = 0;
-
-  for (const file of files) {
-    const path = join(cwd, file);
-    if (!existsSync(path)) continue;
-    scanned++;
-
-    const lines = readFileSync(path, "utf-8").split("\n");
-    lines.forEach((line, index) => {
-      const todoMatch = line.match(/^\s*[-*]\s+\[ \]\s+(.*)$/);
-      const inlineMatch = line.match(/TODO[:\s-]+(.+)/i);
-      const content = todoMatch?.[1] || inlineMatch?.[1];
-      if (!content) return;
-
-      const title = content.trim();
-      const key = `${file}:${index + 1}:${title}`;
-      if (seen.has(key)) return;
-      seen.add(key);
-
-      items.push({
-        id: `claude-${file}-${index + 1}`,
-        source: "claude",
-        title,
-        details: `${file}:${index + 1}`,
-      });
-    });
-  }
-
-  if (scanned === 0) {
-    return {
-      items: [],
-      report: {
-        source: "claude",
-        status: "skipped",
-        detail: "no CLAUDE.md or AGENTS.md found",
-        items: 0,
-      },
-    };
-  }
-
-  return {
-    items,
-    report: {
-      source: "claude",
-      status: "ok",
-      items: items.length,
-    },
-  };
-}
-
-function discoverGitStaleness(
-  cwd: string,
-  staleDays: number,
-): { items: WorkItem[]; report: DiscoveryReport } {
-  let root = "";
-  try {
-    root = execSync(`git -C "${cwd}" rev-parse --show-toplevel`, {
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "pipe"],
-    }).trim();
-  } catch {
-    return {
-      items: [],
-      report: {
-        source: "git",
-        status: "skipped",
-        detail: "not a git repository",
-        items: 0,
-      },
-    };
-  }
-
-  let lastCommit = "";
-  try {
-    lastCommit = execSync(`git -C "${root}" log -1 --format=%ct`, {
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "pipe"],
-    }).trim();
-  } catch {
-    return {
-      items: [],
-      report: {
-        source: "git",
-        status: "error",
-        detail: "unable to read git history",
-        items: 0,
-      },
-    };
-  }
-
-  const lastCommitSeconds = Number(lastCommit);
-  if (!lastCommitSeconds) {
-    return {
-      items: [],
-      report: {
-        source: "git",
-        status: "error",
-        detail: "invalid commit timestamp",
-        items: 0,
-      },
-    };
-  }
-
-  const ageDays = Math.floor((Date.now() / 1000 - lastCommitSeconds) / 86400);
-  if (ageDays < staleDays) {
-    return {
-      items: [],
-      report: {
-        source: "git",
-        status: "ok",
-        detail: `last commit ${ageDays}d ago`,
-        items: 0,
-      },
-    };
-  }
-
-  return {
-    items: [
-      {
-        id: `git-stale-${root.split("/").pop() || "repo"}`,
-        source: "git",
-        title: `Repository idle for ${ageDays}d`,
-        details: `Last commit ${ageDays}d ago in ${root}`,
-      },
-    ],
-    report: {
-      source: "git",
-      status: "ok",
-      detail: `last commit ${ageDays}d ago`,
-      items: 1,
-    },
-  };
-}
-
-async function discoverLinearWork(
-  options: DiscoveryOptions,
-): Promise<{ items: WorkItem[]; report: DiscoveryReport }> {
-  const config = options.linear;
-  if (!config.enabled) {
-    return {
-      items: [],
-      report: {
-        source: "linear",
-        status: "skipped",
-        detail: "linear discovery disabled",
-        items: 0,
-      },
-    };
-  }
-
-  const cachePath = resolveLinearCachePath(config.cachePath);
-  if (cachePath && existsSync(cachePath)) {
-    try {
-      const raw = readFileSync(cachePath, "utf-8");
-      const payload = JSON.parse(raw);
-      const issues = extractLinearIssues(payload);
-      const items = mapLinearIssues(issues, config.project, config.limit, config.team);
-      return {
-        items,
-        report: {
-          source: "linear",
-          status: "ok",
-          detail: `loaded from cache: ${cachePath}`,
-          items: items.length,
-        },
-      };
-    } catch (err) {
-      return {
-        items: [],
-        report: {
-          source: "linear",
-          status: "error",
-          detail: `failed to parse cache: ${(err as Error).message}`,
-          items: 0,
-        },
-      };
-    }
-  }
-
-  if (options.dryRun) {
-    return {
-      items: [],
-      report: {
-        source: "linear",
-        status: "skipped",
-        detail: "dry-run without cache",
-        items: 0,
-      },
-    };
-  }
-
-  if (!config.apiKey) {
-    return {
-      items: [],
-      report: {
-        source: "linear",
-        status: "skipped",
-        detail: "missing LINEAR_API_KEY",
-        items: 0,
-      },
-    };
-  }
-
-  try {
-    let leaseAcquired = false;
-    if (options.resources && options.sessionId) {
-      const lease = options.resources.acquire("linear_api", options.sessionId, "auto");
-      if (!lease) {
-        return {
-          items: [],
-          report: {
-            source: "linear",
-            status: "skipped",
-            detail: "linear resource at capacity",
-            items: 0,
-          },
-        };
-      }
-      leaseAcquired = true;
-    }
-
-    const issues = await fetchLinearIssues(config.apiKey, config.apiUrl, config.limit, config.team);
-    if (leaseAcquired) {
-      options.resources?.release("linear_api", options.sessionId!);
-    }
-    const items = mapLinearIssues(issues, config.project, config.limit, config.team);
-    return {
-      items,
-      report: {
-        source: "linear",
-        status: "ok",
-        detail: config.team ? `team: ${config.team}` : undefined,
-        items: items.length,
-      },
-    };
-  } catch (err) {
-    if (options.resources && options.sessionId) {
-      options.resources.release("linear_api", options.sessionId);
-    }
-    return {
-      items: [],
-      report: {
-        source: "linear",
-        status: "error",
-        detail: (err as Error).message,
-        items: 0,
-      },
-    };
-  }
-}
-
-function resolveLinearCachePath(cachePath?: string): string | undefined {
-  if (cachePath) return expandHome(cachePath);
-  const envPath = process.env.LINEAR_ISSUES_PATH || process.env.LINEAR_CACHE_PATH;
-  if (envPath) return expandHome(envPath);
-  return undefined;
-}
-
-function expandHome(path: string): string {
-  if (path.startsWith("~")) {
-    return path.replace("~", process.env.HOME || "");
-  }
-  return path;
-}
-
-async function fetchLinearIssues(
-  apiKey: string,
-  apiUrl: string | undefined,
-  limit: number,
-  team?: string,
-): Promise<LinearIssue[]> {
-  const url = apiUrl || "https://api.linear.app/graphql";
-
-  // Use team filter when team is specified, otherwise fall back to assigned issues
-  const query = team
-    ? `
-    query TeamIssues($first: Int, $filter: IssueFilter) {
-      issues(first: $first, filter: $filter, orderBy: updatedAt) {
-        nodes {
-          id
-          identifier
-          title
-          description
-          url
-          priority
-          project { name }
-          state { name type }
-        }
-      }
-    }
-  `
-    : `
-    query AutoDiscovery($first: Int) {
-      viewer {
-        assignedIssues(first: $first, orderBy: updatedAt) {
-          nodes {
-            id
-            identifier
-            title
-            description
-            url
-            priority
-            project { name }
-            state { name type }
-          }
-        }
-      }
-    }
-  `;
-
-  const variables = team
-    ? { first: limit, filter: { team: { key: { eq: team } } } }
-    : { first: limit };
-
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: apiKey,
-    },
-    body: JSON.stringify({
-      query,
-      variables,
-    }),
-  });
-
-  if (!response.ok) {
-    throw new Error(`linear api error: ${response.status}`);
-  }
-
-  const payload = await response.json();
-  return extractLinearIssues(payload);
-}
-
-function extractLinearIssues(payload: unknown): LinearIssue[] {
-  if (Array.isArray(payload)) {
-    return payload as LinearIssue[];
-  }
-
-  if (!payload || typeof payload !== "object") {
-    return [];
-  }
-
-  const data = payload as Record<string, unknown>;
-
-  const issues = data.issues;
-  if (Array.isArray(issues)) {
-    return issues as LinearIssue[];
-  }
-
-  const nodes = data.nodes;
-  if (Array.isArray(nodes)) {
-    return nodes as LinearIssue[];
-  }
-
-  const dataField = data.data;
-  if (!dataField || typeof dataField !== "object") {
-    return [];
-  }
-
-  const dataObj = dataField as Record<string, unknown>;
-
-  // Issues query (with filter): data.issues.nodes
-  const issuesField = dataObj.issues;
-  if (issuesField && typeof issuesField === "object") {
-    const issuesObj = issuesField as Record<string, unknown>;
-    const issuesNodes = issuesObj.nodes;
-    if (Array.isArray(issuesNodes)) {
-      return issuesNodes as LinearIssue[];
-    }
-  }
-
-  // Viewer query: data.viewer.assignedIssues.nodes
-  const viewerField = dataObj.viewer;
-  if (viewerField && typeof viewerField === "object") {
-    const viewerObj = viewerField as Record<string, unknown>;
-    const assignedIssuesField = viewerObj.assignedIssues;
-    if (assignedIssuesField && typeof assignedIssuesField === "object") {
-      const assignedIssuesObj = assignedIssuesField as Record<string, unknown>;
-      const viewerNodes = assignedIssuesObj.nodes;
-      if (Array.isArray(viewerNodes)) {
-        return viewerNodes as LinearIssue[];
-      }
-    }
-  }
-
-  return [];
-}
-
-function mapLinearIssues(
-  issues: LinearIssue[],
-  project: string | undefined,
-  limit: number,
-  team?: string,
-): WorkItem[] {
-  const items: WorkItem[] = [];
-
-  for (const issue of issues) {
-    const stateType = issue.state?.type?.toLowerCase();
-    if (stateType === "completed" || stateType === "canceled") {
-      continue;
-    }
-
-    if (project && issue.project?.name && issue.project.name !== project) {
-      continue;
-    }
-
-    // Filter by team prefix (e.g., "ARBOR-" for ARBOR team)
-    if (team && issue.identifier) {
-      const teamPrefix = `${team}-`;
-      if (!issue.identifier.startsWith(teamPrefix)) {
-        continue;
-      }
-    }
-
-    const identifier = issue.identifier || issue.id || "linear";
-    const title = issue.title || "Untitled Linear issue";
-
-    items.push({
-      id: `linear-${identifier}`,
-      source: "linear",
-      title,
-      details: issue.description,
-      issue: issue.identifier,
-      url: issue.url,
-      project: issue.project?.name,
-      priority: issue.priority,
-      metadata: {
-        state: issue.state?.name,
-      },
-    });
-
-    if (items.length >= limit) {
-      break;
-    }
-  }
-
-  return items;
-}