@creativeintelligence/abbie 0.1.4 → 0.1.5

package/src/lib/auto/ideate.ts

@@ -1,412 +0,0 @@
-import { execSync, spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import type { WorkItem } from "./discover.js";
-
-/**
- * Git trajectory signal from recent commits.
- */
-export interface GitSignal {
-  type: "feature" | "bugfix" | "refactor" | "chore";
-  area: string; // e.g., "web/components/chat"
-  summary: string;
-  commits: number;
-  lastCommit: string;
-  authors: string[];
-}
-
-/**
- * Codebase signal from analysis.
- */
-export interface CodebaseSignal {
-  type: "untested" | "complex" | "stale" | "dead_code" | "missing_types" | "todo";
-  path: string;
-  detail: string;
-  severity: "low" | "medium" | "high";
-}
-
-/**
- * Ideated work item (before becoming a tracking issue).
- */
-export interface IdeatedWork {
-  title: string;
-  description: string;
-  type: "feature" | "improvement" | "bug" | "refactor" | "chore";
-  complexity: "trivial" | "simple" | "medium" | "complex";
-  agent: "copilot" | "claude" | "codex";
-  confidence: number;
-  reasoning: string;
-  signals: Array<GitSignal | CodebaseSignal>;
-  suggested_prompt: string;
-}
-
-/**
- * Ideation result.
- */
-export interface IdeationResult {
-  git_signals: GitSignal[];
-  codebase_signals: CodebaseSignal[];
-  ideated_work: IdeatedWork[];
-  sources_analyzed: string[];
-}
-
-export interface IdeationOptions {
-  cwd: string;
-  paths: string[]; // Focus paths (e.g., ["ts-packages/web", "ts-packages/www"])
-  limit: number;
-  commitDays: number; // How many days of commits to analyze
-  dryRun: boolean;
-}
-
-/**
- * Analyze git trajectory to understand recent work patterns.
- */
-export function analyzeGitTrajectory(cwd: string, paths: string[], days: number = 14): GitSignal[] {
-  const signals: GitSignal[] = [];
-  const since = `${days}.days.ago`;
-
-  for (const path of paths) {
-    const fullPath = join(cwd, path);
-    if (!existsSync(fullPath)) continue;
-
-    try {
-      // Get recent commits for this path
-      const logOutput = execSync(
-        `git log --oneline --since="${since}" --format="%h|%s|%an" -- "${path}"`,
-        { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] },
-      ).trim();
-
-      if (!logOutput) continue;
-
-      const commits = logOutput.split("\n").filter(Boolean);
-      const authors = [...new Set(commits.map((c) => c.split("|")[2]))];
-
-      // Categorize by commit message patterns
-      const features = commits.filter((c) => /feat|add|implement|new/i.test(c));
-      const bugfixes = commits.filter((c) => /fix|bug|patch|resolve/i.test(c));
-      const refactors = commits.filter((c) => /refactor|restructure|cleanup|clean up/i.test(c));
-
-      if (features.length > 0) {
-        signals.push({
-          type: "feature",
-          area: path,
-          summary: `${features.length} feature commits in ${path}`,
-          commits: features.length,
-          lastCommit: features[0].split("|")[1],
-          authors,
-        });
-      }
-
-      if (bugfixes.length > 0) {
-        signals.push({
-          type: "bugfix",
-          area: path,
-          summary: `${bugfixes.length} bugfix commits in ${path}`,
-          commits: bugfixes.length,
-          lastCommit: bugfixes[0].split("|")[1],
-          authors,
-        });
-      }
-
-      if (refactors.length > 0) {
-        signals.push({
-          type: "refactor",
-          area: path,
-          summary: `${refactors.length} refactor commits in ${path}`,
-          commits: refactors.length,
-          lastCommit: refactors[0].split("|")[1],
-          authors,
-        });
-      }
-    } catch {
-      // Skip paths with git errors
-    }
-  }
-
-  return signals;
-}
-
-/**
- * Analyze codebase for gaps and issues.
- */
-export function analyzeCodebase(cwd: string, paths: string[]): CodebaseSignal[] {
-  const signals: CodebaseSignal[] = [];
-
-  for (const path of paths) {
-    const fullPath = join(cwd, path);
-    if (!existsSync(fullPath)) continue;
-
-    // Check for files without tests
-    try {
-      const tsFiles = execSync(
-        `find "${fullPath}" -name "*.ts" -o -name "*.tsx" | grep -v ".test." | grep -v ".spec." | grep -v "node_modules" | head -50`,
-        { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] },
-      )
-        .trim()
-        .split("\n")
-        .filter(Boolean);
-
-      for (const file of tsFiles) {
-        const testFile = file.replace(/\.tsx?$/, ".test.ts");
-        const testFile2 = file.replace(/\.tsx?$/, ".test.tsx");
-        if (!existsSync(testFile) && !existsSync(testFile2)) {
-          // Check if file is substantial (>50 lines)
-          try {
-            const lineCount = parseInt(
-              execSync(`wc -l < "${file}"`, { encoding: "utf-8" }).trim(),
-              10,
-            );
-            if (lineCount > 50) {
-              signals.push({
-                type: "untested",
-                path: file.replace(`${cwd}/`, ""),
-                detail: `${lineCount} lines with no test file`,
-                severity: lineCount > 200 ? "high" : lineCount > 100 ? "medium" : "low",
-              });
-            }
-          } catch {
-            // Skip
-          }
-        }
-      }
-    } catch {
-      // Skip
-    }
-
-    // Check for complexity via outline (if available)
-    try {
-      const result = spawnSync("outline", ["--complexity", "--min-complexity=15", fullPath], {
-        cwd,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"],
-      });
-
-      if (result.status === 0 && result.stdout) {
-        const lines = result.stdout.split("\n").filter((l) => l.includes("complexity"));
-        for (const line of lines.slice(0, 5)) {
-          signals.push({
-            type: "complex",
-            path: path,
-            detail: line.trim(),
-            severity: "medium",
-          });
-        }
-      }
-    } catch {
-      // outline not available
-    }
-
-    // Check for TODOs
-    try {
-      const todoLines = execSync(
-        `grep -r --include="*.ts" --include="*.tsx" "TODO" "${fullPath}" | grep -v "node_modules" | head -5`,
-        { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] },
-      )
-        .trim()
-        .split("\n")
-        .filter(Boolean);
-
-      if (todoLines.length > 0) {
-        signals.push({
-          type: "todo",
-          path: path,
-          detail: `Found ${todoLines.length} TODOs (sample: "${todoLines[0].split(":").slice(1).join(":").trim().substring(0, 50)}...")`,
-          severity: "low",
-        });
-      }
-    } catch {
-      // ignore
-    }
-  }
-
-  return signals;
-}
-
-/**
- * Build ideation prompt for LLM.
- */
-function buildIdeationPrompt(
-  gitSignals: GitSignal[],
-  codebaseSignals: CodebaseSignal[],
-  project: string,
-): string {
-  const gitContext = gitSignals
-    .map(
-      (s) =>
-        `- [${s.type}] ${s.area}: ${s.summary} (${s.commits} commits, last: "${s.lastCommit}")`,
-    )
-    .join("\n");
-
-  const codebaseContext = codebaseSignals
-    .map((s) => `- [${s.type}/${s.severity}] ${s.path}: ${s.detail}`)
-    .join("\n");
-
-  return `<role>
-You are a senior product engineer analyzing a codebase to identify high-impact work.
-Project: ${project}
-</role>
-
-<git_trajectory>
-Recent development activity:
-${gitContext || "No recent commits in focus areas"}
-</git_trajectory>
-
-<codebase_analysis>
-Code quality signals:
-${codebaseContext || "No issues detected"}
-</codebase_analysis>
-
-<task>
-Based on the git trajectory and codebase analysis, ideate 3-5 high-impact work items.
-Focus on:
-1. Following up on recent features (polish, edge cases, tests)
-2. Addressing code quality issues (tests, complexity)
-3. Improvements that align with development momentum
-
-For each work item, provide:
-- title: concise description
-- type: feature | improvement | bug | refactor | chore
-- complexity: trivial | simple | medium | complex
-- agent: copilot (simple) | claude (medium) | codex (complex)
-- confidence: 1-10 (how confident this is valuable work)
-- reasoning: why this work matters
-- suggested_prompt: what to tell the agent
-</task>
-
-<output_contract>
-CRITICAL: Respond with ONLY valid JSON array:
-[
-  {
-    "title": "Add tests for chat components",
-    "type": "improvement",
-    "complexity": "medium",
-    "agent": "claude",
-    "confidence": 8,
-    "reasoning": "Recent chat features lack test coverage, increasing regression risk",
-    "suggested_prompt": "Add comprehensive tests for chat components in ts-packages/web/components/chat/"
-  }
-]
-</output_contract>`;
-}
-
-/**
- * Synthesize work items using LLM.
- */
-export async function synthesizeWork(
-  gitSignals: GitSignal[],
-  codebaseSignals: CodebaseSignal[],
-  project: string,
-  dryRun: boolean = false,
-): Promise<IdeatedWork[]> {
-  if (gitSignals.length === 0 && codebaseSignals.length === 0) {
-    return [];
-  }
-
-  const prompt = buildIdeationPrompt(gitSignals, codebaseSignals, project);
-
-  // Save prompt for debugging
-  const promptDir = join(homedir(), ".abbie", "auto", "ideation");
-  mkdirSync(promptDir, { recursive: true });
-  const promptPath = join(promptDir, `ideation-${Date.now()}.md`);
-  writeFileSync(promptPath, prompt);
-
-  if (dryRun) {
-    return [];
-  }
-
-  try {
-    const canUseGemini = spawnSync("which", ["gemini"], { stdio: "pipe" }).status === 0;
-    const canUseCopilot = spawnSync("which", ["copilot"], { stdio: "pipe" }).status === 0;
-
-    if (!canUseGemini && !canUseCopilot) {
-      return [];
-    }
-
-    const result = canUseGemini
-      ? spawnSync("gemini", ["-p", prompt, "-m", "gemini-3-flash"], {
-          encoding: "utf-8",
-          timeout: 60000,
-          stdio: ["ignore", "pipe", "pipe"],
-        })
-      : spawnSync(
-          "copilot",
-          [
-            "-p",
-            prompt,
-            "--model",
-            "gemini-3-pro-preview",
-            "--yolo",
-            "--silent",
-            "--stream",
-            "off",
-          ],
-          {
-            encoding: "utf-8",
-            timeout: 60000,
-            stdio: ["ignore", "pipe", "pipe"],
-          },
-        );
-
-    const stdout = result.stdout?.toString?.() ?? String(result.stdout ?? "");
-    const jsonMatch = stdout.match(/\[[\s\S]*\]/);
-    if (!jsonMatch) return [];
-
-    const items = JSON.parse(jsonMatch[0]) as IdeatedWork[];
-
-    // Add signals to each item
-    return items.map((item) => ({
-      ...item,
-      signals: [...gitSignals, ...codebaseSignals],
-    }));
-  } catch (err) {
-    console.error("Ideation synthesis failed:", (err as Error).message);
-    return [];
-  }
-}
-
-/**
- * Main ideation function.
- */
-export async function ideateWork(options: IdeationOptions): Promise<IdeationResult> {
-  const { cwd, paths, limit, commitDays, dryRun } = options;
-  const project = cwd.split("/").pop() || "unknown";
-
-  // Analyze git trajectory
-  const gitSignals = analyzeGitTrajectory(cwd, paths, commitDays);
-
-  // Analyze codebase
-  const codebaseSignals = analyzeCodebase(cwd, paths);
-
-  // Synthesize work via LLM
-  const ideatedWork = await synthesizeWork(gitSignals, codebaseSignals, project, dryRun);
-
-  return {
-    git_signals: gitSignals,
-    codebase_signals: codebaseSignals,
-    ideated_work: ideatedWork.slice(0, limit),
-    sources_analyzed: paths,
-  };
-}
-
-/**
- * Convert ideated work to WorkItem format for auto pipeline.
- */
-export function ideatedToWorkItem(ideated: IdeatedWork, index: number): WorkItem {
-  return {
-    id: `ideated-${Date.now()}-${index}`,
-    source: "claude" as const,
-    title: ideated.title,
-    details: ideated.suggested_prompt,
-    effort:
-      ideated.complexity === "trivial" || ideated.complexity === "simple" ? "quick" : "thorough",
-    metadata: {
-      type: ideated.type,
-      complexity: ideated.complexity,
-      agent: ideated.agent,
-      confidence: ideated.confidence,
-      reasoning: ideated.reasoning,
-      ideated: true,
-    },
-  };
-}