@leing2021/super-pi 0.14.0

package/extensions/ce-core/tools/session-checkpoint.ts

@@ -0,0 +1,212 @@
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises"
+import path from "node:path"
+import { normalizeSlug } from "../utils/name-utils"
+
+export interface SessionCheckpointInput {
+  operation: "save" | "load" | "list" | "fail" | "retry"
+  repoRoot: string
+  planPath?: string
+  completedUnits?: string[]
+  failedUnit?: string
+  error?: string
+}
+
+export interface CheckpointEntry {
+  planPath: string
+  completedUnits: string[]
+  updatedAt: string
+  status?: "active" | "failed"
+  failedUnit?: string
+  error?: string
+}
+
+export interface SessionCheckpointResult {
+  operation: string
+  planPath?: string
+  completedUnits?: string[]
+  updatedAt?: string
+  status?: string
+  failedUnit?: string
+  error?: string
+  strategy?: string
+  retryFrom?: string
+  checkpoints?: CheckpointEntry[]
+}
+
+function checkpointDir(repoRoot: string): string {
+  return path.join(repoRoot, ".context", "compound-engineering", "checkpoints")
+}
+
+function checkpointPath(repoRoot: string, planPath: string): string {
+  const slug = normalizeSlug(planPath.replace(/\//g, "-"))
+  return path.join(checkpointDir(repoRoot), `${slug}.json`)
+}
+
+export function createSessionCheckpointTool() {
+  return {
+    name: "session_checkpoint",
+    async execute(input: SessionCheckpointInput): Promise<SessionCheckpointResult> {
+      switch (input.operation) {
+        case "save":
+          return saveCheckpoint(input)
+        case "load":
+          return loadCheckpoint(input)
+        case "list":
+          return listCheckpoints(input)
+        case "fail":
+          return failCheckpoint(input)
+        case "retry":
+          return retryCheckpoint(input)
+        default:
+          throw new Error(`Unknown operation: ${input.operation}`)
+      }
+    },
+  }
+}
+
+async function readEntry(repoRoot: string, planPath: string): Promise<CheckpointEntry | null> {
+  const filePath = checkpointPath(repoRoot, planPath)
+  try {
+    const content = await readFile(filePath, "utf8")
+    return JSON.parse(content)
+  } catch {
+    return null
+  }
+}
+
+async function writeEntry(repoRoot: string, entry: CheckpointEntry): Promise<void> {
+  const filePath = checkpointPath(repoRoot, entry.planPath)
+  await mkdir(path.dirname(filePath), { recursive: true })
+  await writeFile(filePath, JSON.stringify(entry, null, 2), "utf8")
+}
+
+async function saveCheckpoint(input: SessionCheckpointInput): Promise<SessionCheckpointResult> {
+  const planPath = required(input.planPath, "planPath")
+  const completedUnits = input.completedUnits ?? []
+
+  const entry: CheckpointEntry = {
+    planPath,
+    completedUnits,
+    updatedAt: new Date().toISOString(),
+    status: "active",
+  }
+
+  await writeEntry(input.repoRoot, entry)
+
+  return {
+    operation: "save",
+    planPath,
+    completedUnits,
+    updatedAt: entry.updatedAt,
+  }
+}
+
+async function loadCheckpoint(input: SessionCheckpointInput): Promise<SessionCheckpointResult> {
+  const planPath = required(input.planPath, "planPath")
+  const entry = await readEntry(input.repoRoot, planPath)
+
+  if (!entry) {
+    return { operation: "load", planPath, completedUnits: [] }
+  }
+
+  return {
+    operation: "load",
+    planPath: entry.planPath,
+    completedUnits: entry.completedUnits,
+    updatedAt: entry.updatedAt,
+  }
+}
+
+async function listCheckpoints(input: SessionCheckpointInput): Promise<SessionCheckpointResult> {
+  const dir = checkpointDir(input.repoRoot)
+
+  try {
+    const files = await readdir(dir)
+    const checkpoints: CheckpointEntry[] = []
+
+    for (const file of files) {
+      if (file.endsWith(".json")) {
+        try {
+          const content = await readFile(path.join(dir, file), "utf8")
+          checkpoints.push(JSON.parse(content))
+        } catch {
+          // Skip malformed files
+        }
+      }
+    }
+
+    return { operation: "list", checkpoints }
+  } catch {
+    return { operation: "list", checkpoints: [] }
+  }
+}
+
+async function failCheckpoint(input: SessionCheckpointInput): Promise<SessionCheckpointResult> {
+  const planPath = required(input.planPath, "planPath")
+  const entry = await readEntry(input.repoRoot, planPath)
+
+  if (!entry) {
+    throw new Error("No checkpoint found. Use 'save' first.")
+  }
+
+  entry.status = "failed"
+  entry.failedUnit = input.failedUnit ?? ""
+  entry.error = input.error ?? ""
+  entry.updatedAt = new Date().toISOString()
+
+  await writeEntry(input.repoRoot, entry)
+
+  return {
+    operation: "fail",
+    planPath: entry.planPath,
+    status: "failed",
+    failedUnit: entry.failedUnit,
+    error: entry.error,
+    completedUnits: entry.completedUnits,
+    updatedAt: entry.updatedAt,
+  }
+}
+
+async function retryCheckpoint(input: SessionCheckpointInput): Promise<SessionCheckpointResult> {
+  const planPath = required(input.planPath, "planPath")
+  const entry = await readEntry(input.repoRoot, planPath)
+
+  if (!entry) {
+    throw new Error("No checkpoint found.")
+  }
+
+  if (entry.status !== "failed") {
+    throw new Error("Checkpoint is not in a failed state. Nothing to retry.")
+  }
+
+  // Determine retry strategy based on error type
+  const errorLower = (entry.error ?? "").toLowerCase()
+  let strategy = "retry-unit"
+
+  if (errorLower.includes("timeout")) {
+    strategy = "retry-with-longer-timeout"
+  } else if (errorLower.includes("permission") || errorLower.includes("access")) {
+    strategy = "check-permissions-then-retry"
+  } else if (errorLower.includes("typeerror") || errorLower.includes("syntax")) {
+    strategy = "fix-code-then-retry"
+  } else if (errorLower.includes("not found") || errorLower.includes("enoent")) {
+    strategy = "verify-files-then-retry"
+  }
+
+  return {
+    operation: "retry",
+    planPath: entry.planPath,
+    status: "retry",
+    retryFrom: entry.failedUnit,
+    completedUnits: entry.completedUnits,
+    strategy,
+    updatedAt: entry.updatedAt,
+  }
+}
+
+function required(value: string | undefined, field: string): string {
+  if (!value) {
+    throw new Error(`session_checkpoint requires ${field}`)
+  }
+  return value
+}

package/extensions/ce-core/tools/session-history.ts

@@ -0,0 +1,117 @@
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises"
+import path from "node:path"
+import { normalizeSlug } from "../utils/name-utils"
+
+export interface HistoryEntry {
+  id: string
+  skill: string
+  artifactPath: string
+  summary: string
+  timestamp: string
+}
+
+export interface SessionHistoryInput {
+  operation: "record" | "query" | "latest"
+  repoRoot: string
+  skill?: string
+  artifactPath?: string
+  summary?: string
+}
+
+export interface SessionHistoryResult {
+  operation: string
+  entries: HistoryEntry[]
+}
+
+function historyDir(repoRoot: string): string {
+  return path.join(repoRoot, ".context", "compound-engineering", "history")
+}
+
+let _counter = 0
+
+export function _resetCounter() { _counter = 0 }
+
+export function createSessionHistoryTool() {
+  return {
+    name: "session_history",
+    async execute(input: SessionHistoryInput): Promise<SessionHistoryResult> {
+      switch (input.operation) {
+        case "record":
+          return recordExecution(input)
+        case "query":
+          return queryHistory(input)
+        case "latest":
+          return latestPerSkill(input)
+        default:
+          throw new Error(`Unknown operation: ${input.operation}`)
+      }
+    },
+  }
+}
+
+async function ensureDir(dir: string): Promise<void> {
+  await mkdir(dir, { recursive: true })
+}
+
+async function readAllEntries(repoRoot: string): Promise<HistoryEntry[]> {
+  const dir = historyDir(repoRoot)
+  try {
+    const files = await readdir(dir)
+    const entries: HistoryEntry[] = []
+    for (const file of files) {
+      if (file.endsWith(".json")) {
+        try {
+          const content = await readFile(path.join(dir, file), "utf8")
+          entries.push(JSON.parse(content))
+        } catch {
+          // skip malformed
+        }
+      }
+    }
+    return entries.sort((a, b) => a.id.localeCompare(b.id))
+  } catch {
+    return []
+  }
+}
+
+async function recordExecution(input: SessionHistoryInput): Promise<SessionHistoryResult> {
+  const dir = historyDir(input.repoRoot)
+  await ensureDir(dir)
+
+  const id = `${Date.now()}-${String(++_counter).padStart(6, "0")}-${normalizeSlug(input.skill ?? "unknown")}`
+  const entry: HistoryEntry = {
+    id,
+    skill: input.skill ?? "",
+    artifactPath: input.artifactPath ?? "",
+    summary: input.summary ?? "",
+    timestamp: new Date().toISOString(),
+  }
+
+  const filePath = path.join(dir, `${id}.json`)
+  await writeFile(filePath, JSON.stringify(entry, null, 2), "utf8")
+
+  return { operation: "record", entries: [entry] }
+}
+
+async function queryHistory(input: SessionHistoryInput): Promise<SessionHistoryResult> {
+  const all = await readAllEntries(input.repoRoot)
+  const filtered = input.skill
+    ? all.filter((e) => e.skill === input.skill)
+    : all
+
+  return { operation: "query", entries: filtered }
+}
+
+async function latestPerSkill(input: SessionHistoryInput): Promise<SessionHistoryResult> {
+  const all = await readAllEntries(input.repoRoot)
+  const latestMap = new Map<string, HistoryEntry>()
+
+  for (const entry of all) {
+    const existing = latestMap.get(entry.skill)
+    if (!existing || entry.id > existing.id) {
+      latestMap.set(entry.skill, entry)
+    }
+  }
+
+  return { operation: "latest", entries: Array.from(latestMap.values()) }
+}

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

@@ -0,0 +1,59 @@
+export interface SubagentTask {
+  agent: string
+  task: string
+}
+
+export interface SubagentInput {
+  agent?: string
+  task?: string
+  chain?: SubagentTask[]
+}
+
+export interface SubagentResult {
+  mode: "single" | "chain"
+  outputs: string[]
+}
+
+export type SubagentRunner = (prompt: string) => Promise<string>
+
+export function createSubagentTool() {
+  return {
+    name: "subagent",
+    async execute(input: SubagentInput, runner: SubagentRunner): Promise<SubagentResult> {
+      const hasSingle = Boolean(input.agent && input.task)
+      const hasChain = Boolean(input.chain && input.chain.length > 0)
+
+      if (Number(hasSingle) + Number(hasChain) !== 1) {
+        throw new Error("Provide exactly one mode: single or chain")
+      }
+
+      if (hasSingle) {
+        const prompt = buildPrompt(input.agent!, input.task!)
+        const output = await runner(prompt)
+        return {
+          mode: "single",
+          outputs: [output],
+        }
+      }
+
+      const outputs: string[] = []
+      let previous = ""
+
+      for (const task of input.chain ?? []) {
+        const prompt = buildPrompt(task.agent, task.task.replace(/\{previous\}/g, previous))
+        const output = await runner(prompt)
+        outputs.push(output)
+        previous = output
+      }
+
+      return {
+        mode: "chain",
+        outputs,
+      }
+    },
+  }
+}
+
+function buildPrompt(agent: string, task: string): string {
+  return `/skill:${agent} ${task}`
+}

package/extensions/ce-core/tools/task-splitter.ts

@@ -0,0 +1,122 @@
+export interface SplitterUnit {
+  name: string
+  files: string[]
+}
+
+export interface SplitterGroup {
+  units: string[]
+  parallelSafe: boolean
+  sharedFiles?: string[]
+}
+
+export interface TaskSplitterInput {
+  units: SplitterUnit[]
+}
+
+export interface TaskSplitterResult {
+  groups: SplitterGroup[]
+  independentUnits: string[]
+  dependentUnits: string[]
+}
+
+export function createTaskSplitterTool() {
+  return {
+    name: "task_splitter",
+    execute(input: TaskSplitterInput): TaskSplitterResult {
+      if (input.units.length === 0) {
+        return { groups: [], independentUnits: [], dependentUnits: [] }
+      }
+
+      // Build file → unit names map
+      const fileToUnits = new Map<string, string[]>()
+      for (const unit of input.units) {
+        for (const file of unit.files) {
+          const existing = fileToUnits.get(file) ?? []
+          existing.push(unit.name)
+          fileToUnits.set(file, existing)
+        }
+      }
+
+      // Union-Find: merge units that share files
+      const parent = new Map<string, string>()
+      const sharedFilesMap = new Map<string, Set<string>>()
+
+      function find(name: string): string {
+        if (!parent.has(name)) parent.set(name, name)
+        let root = name
+        while (parent.get(root) !== root) {
+          root = parent.get(root)!
+        }
+        // Path compression
+        let current = name
+        while (current !== root) {
+          const next = parent.get(current)!
+          parent.set(current, root)
+          current = next
+        }
+        return root
+      }
+
+      function union(a: string, b: string) {
+        const rootA = find(a)
+        const rootB = find(b)
+        if (rootA !== rootB) {
+          parent.set(rootA, rootB)
+        }
+      }
+
+      // Initialize all units
+      for (const unit of input.units) {
+        find(unit.name)
+      }
+
+      // Merge units sharing files
+      for (const [file, unitNames] of fileToUnits) {
+        if (unitNames.length > 1) {
+          for (let i = 1; i < unitNames.length; i++) {
+            union(unitNames[0], unitNames[i])
+          }
+          // Track shared files per root
+          const root = find(unitNames[0])
+          if (!sharedFilesMap.has(root)) sharedFilesMap.set(root, new Set())
+          sharedFilesMap.get(root)!.add(file)
+        }
+      }
+
+      // Build groups by root
+      const rootToUnits = new Map<string, string[]>()
+      for (const unit of input.units) {
+        const root = find(unit.name)
+        const group = rootToUnits.get(root) ?? []
+        group.push(unit.name)
+        rootToUnits.set(root, group)
+      }
+
+      // Build output
+      const groups: SplitterGroup[] = []
+      const independentUnits: string[] = []
+      const dependentUnits: string[] = []
+
+      for (const [root, unitNames] of rootToUnits) {
+        const hasShared = sharedFilesMap.has(root) && sharedFilesMap.get(root)!.size > 0
+        const parallelSafe = !hasShared
+
+        const group: SplitterGroup = {
+          units: unitNames,
+          parallelSafe,
+        }
+
+        if (!parallelSafe) {
+          group.sharedFiles = Array.from(sharedFilesMap.get(root)!)
+          dependentUnits.push(...unitNames)
+        } else {
+          independentUnits.push(...unitNames)
+        }
+
+        groups.push(group)
+      }
+
+      return { groups, independentUnits, dependentUnits }
+    },
+  }
+}

package/extensions/ce-core/tools/workflow-state.ts

@@ -0,0 +1,80 @@
+import { readdirSync, statSync, existsSync } from "node:fs"
+import path from "node:path"
+
+export interface WorkflowCategoryState {
+  count: number
+  latest: string | null
+}
+
+export interface WorkflowStateInput {
+  repoRoot: string
+}
+
+export interface WorkflowStateResult {
+  brainstorms: WorkflowCategoryState
+  plans: WorkflowCategoryState
+  solutions: WorkflowCategoryState
+  runs: WorkflowCategoryState
+}
+
+function emptyCategory(): WorkflowCategoryState {
+  return { count: 0, latest: null }
+}
+
+function scanDir(dirPath: string): WorkflowCategoryState {
+  if (!existsSync(dirPath)) {
+    return emptyCategory()
+  }
+
+  const files = collectFiles(dirPath)
+
+  if (files.length === 0) {
+    return emptyCategory()
+  }
+
+  const sorted = files.sort()
+  const latest = sorted[sorted.length - 1]
+
+  return {
+    count: files.length,
+    latest: path.basename(latest),
+  }
+}
+
+function collectFiles(dirPath: string): string[] {
+  const results: string[] = []
+
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true })
+
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name)
+
+      if (entry.isDirectory()) {
+        results.push(...collectFiles(fullPath))
+      } else if (entry.isFile()) {
+        results.push(fullPath)
+      }
+    }
+  } catch {
+    // Directory not readable, treat as empty
+  }
+
+  return results
+}
+
+export function createWorkflowStateTool() {
+  return {
+    name: "workflow_state",
+    async execute(input: WorkflowStateInput): Promise<WorkflowStateResult> {
+      const repoRoot = input.repoRoot
+
+      return {
+        brainstorms: scanDir(path.join(repoRoot, "docs", "brainstorms")),
+        plans: scanDir(path.join(repoRoot, "docs", "plans")),
+        solutions: scanDir(path.join(repoRoot, "docs", "solutions")),
+        runs: scanDir(path.join(repoRoot, ".context", "compound-engineering")),
+      }
+    },
+  }
+}