@leing2021/super-pi 0.14.0

package/extensions/ce-core/tools/brainstorm-dialog.ts

@@ -0,0 +1,167 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises"
+import path from "node:path"
+import { normalizeSlug } from "../utils/name-utils"
+
+export interface BrainstormDialogInput {
+  operation: "start" | "refine" | "summarize"
+  repoRoot: string
+  artifactPath: string
+  analysis?: string
+  questions?: string[]
+  userResponses?: string[]
+}
+
+export interface DialogState {
+  artifactPath: string
+  round: number
+  status: "in_progress" | "complete"
+  analysis: string
+  openQuestions: string[]
+  history: DialogRound[]
+}
+
+export interface DialogRound {
+  round: number
+  analysis: string
+  questions: string[]
+  userResponses: string[]
+}
+
+export interface BrainstormDialogResult {
+  artifactPath: string
+  round: number
+  status: "in_progress" | "complete"
+  analysis: string
+  openQuestions: string[]
+}
+
+function dialogDir(repoRoot: string): string {
+  return path.join(repoRoot, ".context", "compound-engineering", "dialogs")
+}
+
+function dialogPath(repoRoot: string, artifactPath: string): string {
+  const slug = normalizeSlug(artifactPath.replace(/\//g, "-"))
+  return path.join(dialogDir(repoRoot), `${slug}.json`)
+}
+
+export function createBrainstormDialogTool() {
+  return {
+    name: "brainstorm_dialog",
+    async execute(input: BrainstormDialogInput): Promise<BrainstormDialogResult> {
+      switch (input.operation) {
+        case "start":
+          return startDialog(input)
+        case "refine":
+          return refineDialog(input)
+        case "summarize":
+          return summarizeDialog(input)
+        default:
+          throw new Error(`Unknown operation: ${input.operation}`)
+      }
+    },
+  }
+}
+
+async function readState(repoRoot: string, artifactPath: string): Promise<DialogState | null> {
+  const filePath = dialogPath(repoRoot, artifactPath)
+  try {
+    const content = await readFile(filePath, "utf8")
+    return JSON.parse(content)
+  } catch {
+    return null
+  }
+}
+
+async function writeState(repoRoot: string, state: DialogState): Promise<void> {
+  const filePath = dialogPath(repoRoot, state.artifactPath)
+  await mkdir(path.dirname(filePath), { recursive: true })
+  await writeFile(filePath, JSON.stringify(state, null, 2), "utf8")
+}
+
+async function startDialog(input: BrainstormDialogInput): Promise<BrainstormDialogResult> {
+  const existing = await readState(input.repoRoot, input.artifactPath)
+  if (existing) {
+    return {
+      artifactPath: existing.artifactPath,
+      round: existing.round,
+      status: existing.status,
+      analysis: existing.analysis,
+      openQuestions: existing.openQuestions,
+    }
+  }
+
+  const state: DialogState = {
+    artifactPath: input.artifactPath,
+    round: 1,
+    status: "in_progress",
+    analysis: input.analysis ?? "",
+    openQuestions: input.questions ?? [],
+    history: [
+      {
+        round: 1,
+        analysis: input.analysis ?? "",
+        questions: input.questions ?? [],
+        userResponses: [],
+      },
+    ],
+  }
+
+  await writeState(input.repoRoot, state)
+
+  return {
+    artifactPath: state.artifactPath,
+    round: state.round,
+    status: state.status,
+    analysis: state.analysis,
+    openQuestions: state.openQuestions,
+  }
+}
+
+async function refineDialog(input: BrainstormDialogInput): Promise<BrainstormDialogResult> {
+  const existing = await readState(input.repoRoot, input.artifactPath)
+  if (!existing) {
+    throw new Error("No dialog found. Use 'start' first.")
+  }
+
+  existing.round += 1
+  existing.analysis = input.analysis ?? existing.analysis
+  existing.openQuestions = input.questions ?? []
+
+  existing.history.push({
+    round: existing.round,
+    analysis: existing.analysis,
+    questions: existing.openQuestions,
+    userResponses: input.userResponses ?? [],
+  })
+
+  await writeState(input.repoRoot, existing)
+
+  return {
+    artifactPath: existing.artifactPath,
+    round: existing.round,
+    status: existing.status,
+    analysis: existing.analysis,
+    openQuestions: existing.openQuestions,
+  }
+}
+
+async function summarizeDialog(input: BrainstormDialogInput): Promise<BrainstormDialogResult> {
+  const existing = await readState(input.repoRoot, input.artifactPath)
+  if (!existing) {
+    throw new Error("No dialog found. Use 'start' first.")
+  }
+
+  existing.status = "complete"
+  existing.analysis = input.analysis ?? existing.analysis
+  existing.openQuestions = []
+
+  await writeState(input.repoRoot, existing)
+
+  return {
+    artifactPath: existing.artifactPath,
+    round: existing.round,
+    status: existing.status,
+    analysis: existing.analysis,
+    openQuestions: [],
+  }
+}

package/extensions/ce-core/tools/parallel-subagent.ts

@@ -0,0 +1,54 @@
+export interface ParallelSubagentTask {
+  agent: string
+  task: string
+}
+
+export interface ParallelSubagentInput {
+  tasks: ParallelSubagentTask[]
+}
+
+export interface ParallelResultItem {
+  status: "fulfilled" | "rejected"
+  value?: string
+  reason?: string
+}
+
+export interface ParallelSubagentResult {
+  mode: "parallel"
+  outputs: ParallelResultItem[]
+}
+
+export type SubagentRunner = (prompt: string) => Promise<string>
+
+function buildPrompt(agent: string, task: string): string {
+  return `/skill:${agent} ${task}`
+}
+
+export function createParallelSubagentTool() {
+  return {
+    name: "parallel_subagent",
+    async execute(input: ParallelSubagentInput, runner: SubagentRunner): Promise<ParallelSubagentResult> {
+      if (!input.tasks || input.tasks.length === 0) {
+        throw new Error("parallel_subagent requires at least one task")
+      }
+
+      const promises = input.tasks.map(({ agent, task }) =>
+        runner(buildPrompt(agent, task)),
+      )
+
+      const settled = await Promise.allSettled(promises)
+
+      const outputs: ParallelResultItem[] = settled.map((result) => {
+        if (result.status === "fulfilled") {
+          return { status: "fulfilled", value: result.value }
+        }
+        return { status: "rejected", reason: result.reason?.message || String(result.reason) }
+      })
+
+      return {
+        mode: "parallel",
+        outputs,
+      }
+    },
+  }
+}

package/extensions/ce-core/tools/pattern-extractor.ts

@@ -0,0 +1,139 @@
+export interface ArtifactInput {
+  path: string
+  content: string
+}
+
+export interface Pattern {
+  keyword: string
+  occurrences: number
+  sources: string[]
+}
+
+export interface ExtractInput {
+  operation: "extract"
+  artifacts: ArtifactInput[]
+  keywords?: string[]
+}
+
+export interface ExtractResult {
+  operation: "extract"
+  patterns: Pattern[]
+}
+
+export interface CategorizeInput {
+  operation: "categorize"
+  patterns: Pattern[]
+  categories: Record<string, string[]>
+}
+
+export interface CategorizeResult {
+  operation: "categorize"
+  categories: Record<string, Pattern[]>
+  uncategorized: Pattern[]
+}
+
+export type PatternExtractorInput = ExtractInput | CategorizeInput | { operation: string; artifacts?: ArtifactInput[] }
+export type PatternExtractorResult = ExtractResult | CategorizeResult
+
+function extractKeywords(content: string): string[] {
+  return content
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, " ")
+    .split(/\s+/)
+    .filter((w) => w.length > 2)
+}
+
+function extractWithKeywords(artifacts: ArtifactInput[], keywords: string[]): Pattern[] {
+  const patterns: Pattern[] = []
+
+  for (const keyword of keywords) {
+    const sources: string[] = []
+    let occurrences = 0
+
+    for (const artifact of artifacts) {
+      const regex = new RegExp(keyword, "gi")
+      const matches = artifact.content.match(regex)
+      if (matches && matches.length > 0) {
+        occurrences += matches.length
+        sources.push(artifact.path)
+      }
+    }
+
+    if (occurrences > 0) {
+      patterns.push({ keyword, occurrences, sources })
+    }
+  }
+
+  return patterns.sort((a, b) => b.occurrences - a.occurrences)
+}
+
+function extractAllKeywords(artifacts: ArtifactInput[]): Pattern[] {
+  const wordMap = new Map<string, { count: number; sources: Set<string> }>()
+
+  for (const artifact of artifacts) {
+    const words = extractKeywords(artifact.content)
+    const uniqueWords = new Set(words)
+
+    for (const word of uniqueWords) {
+      const existing = wordMap.get(word) ?? { count: 0, sources: new Set<string>() }
+      existing.count += words.filter((w) => w === word).length
+      existing.sources.add(artifact.path)
+      wordMap.set(word, existing)
+    }
+  }
+
+  return Array.from(wordMap.entries())
+    .map(([keyword, data]) => ({
+      keyword,
+      occurrences: data.count,
+      sources: Array.from(data.sources),
+    }))
+    .sort((a, b) => b.occurrences - a.occurrences)
+}
+
+export function createPatternExtractorTool() {
+  return {
+    name: "pattern_extractor",
+    execute(input: PatternExtractorInput): PatternExtractorResult {
+      switch (input.operation) {
+        case "extract": {
+          const artifacts = (input as ExtractInput).artifacts
+          const keywords = (input as ExtractInput).keywords
+          const patterns = keywords && keywords.length > 0
+            ? extractWithKeywords(artifacts, keywords)
+            : extractAllKeywords(artifacts)
+          return { operation: "extract", patterns }
+        }
+        case "categorize": {
+          const { patterns, categories } = input as CategorizeInput
+          const result: Record<string, Pattern[]> = {}
+          const uncategorized: Pattern[] = []
+          const matched = new Set<string>()
+
+          for (const [category, catKeywords] of Object.entries(categories)) {
+            result[category] = []
+          }
+
+          for (const pattern of patterns) {
+            let found = false
+            for (const [category, catKeywords] of Object.entries(categories)) {
+              if (catKeywords.some((kw) => kw.toLowerCase() === pattern.keyword.toLowerCase())) {
+                result[category].push(pattern)
+                matched.add(pattern.keyword)
+                found = true
+                break
+              }
+            }
+            if (!found) {
+              uncategorized.push(pattern)
+            }
+          }
+
+          return { operation: "categorize", categories: result, uncategorized }
+        }
+        default:
+          throw new Error(`Unknown operation: ${input.operation}`)
+      }
+    },
+  }
+}

package/extensions/ce-core/tools/plan-diff.ts

@@ -0,0 +1,136 @@
+export interface PlanUnit {
+  name: string
+  description: string
+  files: string[]
+}
+
+export interface PlanChange {
+  action: "add" | "remove" | "modify"
+  name: string
+  description?: string
+  files?: string[]
+}
+
+export interface PlanDiffInput {
+  operation: "compare" | "patch"
+  existingUnits: PlanUnit[]
+  newRequirements?: PlanUnit[]
+  changes?: PlanChange[]
+}
+
+export interface CompareResult {
+  operation: "compare"
+  added: PlanUnit[]
+  removed: PlanUnit[]
+  modified: PlanUnit[]
+  unchanged: PlanUnit[]
+}
+
+export interface PatchResult {
+  operation: "patch"
+  units: PlanUnit[]
+  appliedChanges: number
+}
+
+export type PlanDiffResult = CompareResult | PatchResult
+
+function unitKey(u: PlanUnit): string {
+  return u.name
+}
+
+function unitsEqual(a: PlanUnit, b: PlanUnit): boolean {
+  return (
+    a.description === b.description &&
+    a.files.length === b.files.length &&
+    a.files.every((f, i) => f === b.files[i])
+  )
+}
+
+export function createPlanDiffTool() {
+  return {
+    name: "plan_diff",
+    execute(input: PlanDiffInput): PlanDiffResult {
+      switch (input.operation) {
+        case "compare":
+          return compare(input.existingUnits, input.newRequirements ?? [])
+        case "patch":
+          return patch(input.existingUnits, input.changes ?? [])
+        default:
+          throw new Error(`Unknown operation: ${input.operation}`)
+      }
+    },
+  }
+}
+
+function compare(existing: PlanUnit[], newReqs: PlanUnit[]): CompareResult {
+  const existingMap = new Map(existing.map((u) => [unitKey(u), u]))
+  const newMap = new Map(newReqs.map((u) => [unitKey(u), u]))
+
+  const added: PlanUnit[] = []
+  const removed: PlanUnit[] = []
+  const modified: PlanUnit[] = []
+  const unchanged: PlanUnit[] = []
+
+  // Find added and modified
+  for (const [key, newUnit] of newMap) {
+    const existingUnit = existingMap.get(key)
+    if (!existingUnit) {
+      added.push(newUnit)
+    } else if (!unitsEqual(existingUnit, newUnit)) {
+      modified.push(newUnit)
+    } else {
+      unchanged.push(newUnit)
+    }
+  }
+
+  // Find removed
+  for (const [key, existingUnit] of existingMap) {
+    if (!newMap.has(key)) {
+      removed.push(existingUnit)
+    }
+  }
+
+  return { operation: "compare", added, removed, modified, unchanged }
+}
+
+function patch(existing: PlanUnit[], changes: PlanChange[]): PatchResult {
+  const unitMap = new Map(existing.map((u) => [unitKey(u), { ...u }]))
+  let appliedChanges = 0
+
+  for (const change of changes) {
+    switch (change.action) {
+      case "add":
+        unitMap.set(change.name, {
+          name: change.name,
+          description: change.description ?? "",
+          files: change.files ?? [],
+        })
+        appliedChanges++
+        break
+      case "remove":
+        if (unitMap.has(change.name)) {
+          unitMap.delete(change.name)
+          appliedChanges++
+        }
+        break
+      case "modify": {
+        const existing = unitMap.get(change.name)
+        if (existing) {
+          unitMap.set(change.name, {
+            ...existing,
+            description: change.description ?? existing.description,
+            files: change.files ?? existing.files,
+          })
+          appliedChanges++
+        }
+        break
+      }
+    }
+  }
+
+  return {
+    operation: "patch",
+    units: Array.from(unitMap.values()),
+    appliedChanges,
+  }
+}

package/extensions/ce-core/tools/review-router.ts

@@ -0,0 +1,95 @@
+export interface ReviewRouterInput {
+  filesChanged: string[]
+  insertions: number
+  deletions: number
+}
+
+export interface ReviewerRecommendation {
+  name: string
+  reason: string
+}
+
+export interface ReviewRouterResult {
+  reviewers: ReviewerRecommendation[]
+}
+
+interface ReviewerRule {
+  name: string
+  reason: string
+  condition: (input: ReviewRouterInput) => boolean
+}
+
+const BASE_REVIEWERS: ReviewerRule[] = [
+  {
+    name: "correctness-reviewer",
+    reason: "Always review for logical correctness and intended behavior.",
+    condition: () => true,
+  },
+  {
+    name: "testing-reviewer",
+    reason: "Always review test coverage and test quality.",
+    condition: () => true,
+  },
+  {
+    name: "maintainability-reviewer",
+    reason: "Always review code clarity, naming, and structure.",
+    condition: () => true,
+  },
+]
+
+const CONDITIONAL_REVIEWERS: ReviewerRule[] = [
+  {
+    name: "security-reviewer",
+    reason: "Auth, permissions, or user input files were changed.",
+    condition: (input) =>
+      input.filesChanged.some((f) =>
+        /auth|permission|login|password|token|session|credential|crypto/i.test(f),
+      ),
+  },
+  {
+    name: "performance-reviewer",
+    reason: "Data, query, or cache-related files were changed.",
+    condition: (input) =>
+      input.filesChanged.some((f) =>
+        /query|cache|database|db\/|sql|perf|benchmark|stream|batch/i.test(f),
+      ),
+  },
+  {
+    name: "integration-reviewer",
+    reason: "Configuration, CI/CD, or package files were changed.",
+    condition: (input) =>
+      input.filesChanged.some((f) =>
+        /workflows|docker|compose|package\.json|tsconfig|\.env|config/i.test(f),
+      ),
+  },
+  {
+    name: "thoroughness-reviewer",
+    reason: "Large diff with many changes across multiple files.",
+    condition: (input) =>
+      input.filesChanged.length >= 5 ||
+      input.insertions + input.deletions >= 300,
+  },
+]
+
+export function createReviewRouterTool() {
+  return {
+    name: "review_router",
+    async execute(input: ReviewRouterInput): Promise<ReviewRouterResult> {
+      const reviewers: ReviewerRecommendation[] = []
+
+      for (const rule of BASE_REVIEWERS) {
+        if (rule.condition(input)) {
+          reviewers.push({ name: rule.name, reason: rule.reason })
+        }
+      }
+
+      for (const rule of CONDITIONAL_REVIEWERS) {
+        if (rule.condition(input)) {
+          reviewers.push({ name: rule.name, reason: rule.reason })
+        }
+      }
+
+      return { reviewers }
+    },
+  }
+}