pi-crew 0.4.0 → 0.5.1

package/src/state/run-graph.ts

@@ -0,0 +1,180 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { TeamRunManifest, TeamTaskState } from "./types.ts";
+
+export interface RunGraphNode {
+  id: string;
+  type: "run" | "task" | "agent" | "artifact" | "file";
+  name: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface RunGraphEdge {
+  source: string;
+  target: string;
+  type: "dependsOn" | "produces" | "runs" | "contains";
+  weight?: number;
+}
+
+export interface RunGraphLayer {
+  name: string;
+  nodeIds: string[];
+}
+
+export interface RunGraph {
+  version: "1.0.0";
+  runId: string;
+  team: string;
+  workflow: string;
+  createdAt: string;
+  completedAt?: string;
+  status: string;
+  nodes: RunGraphNode[];
+  edges: RunGraphEdge[];
+  layers: RunGraphLayer[];
+}
+
+/**
+ * Build a unified run graph from manifest + tasks.
+ * Consolidates state into a single graph JSON for dashboard/API use.
+ */
+export function buildRunGraph(
+  manifest: TeamRunManifest,
+  tasks: TeamTaskState[],
+): RunGraph {
+  const nodes: RunGraphNode[] = [];
+  const edges: RunGraphEdge[] = [];
+  const nodeIds = new Set<string>();
+
+  // Add run node
+  const runId = manifest.runId;
+  nodes.push({
+    id: `run:${runId}`,
+    type: "run",
+    name: manifest.goal ?? runId,
+    metadata: {
+      team: manifest.team,
+      workflow: manifest.workflow,
+      status: manifest.status,
+      createdAt: manifest.createdAt,
+    },
+  });
+  nodeIds.add(`run:${runId}`);
+
+  // Add task nodes
+  for (const task of tasks) {
+    const taskId = `task:${task.id}`;
+    if (nodeIds.has(taskId)) continue;
+    nodeIds.add(taskId);
+
+    nodes.push({
+      id: taskId,
+      type: "task",
+      name: task.role,
+      metadata: {
+        status: task.status,
+        startedAt: task.startedAt,
+        finishedAt: task.finishedAt,
+      },
+    });
+
+    // Edge from run to task
+    edges.push({
+      source: `run:${runId}`,
+      target: taskId,
+      type: "contains",
+    });
+
+    // Edges from dependencies
+    for (const dep of task.dependsOn ?? []) {
+      edges.push({
+        source: `task:${dep}`,
+        target: taskId,
+        type: "dependsOn",
+        weight: 1.0,
+      });
+    }
+
+  }
+
+  // Group by layer (based on phase or role)
+  const layerMap = new Map<string, string[]>();
+  for (const task of tasks) {
+    const layerName = task.adaptive?.phase ?? task.role;
+    if (!layerMap.has(layerName)) layerMap.set(layerName, []);
+    layerMap.get(layerName)!.push(`task:${task.id}`);
+  }
+
+  const layers: RunGraphLayer[] = [...layerMap.entries()].map(([name, nodeIdList]) => ({
+    name,
+    nodeIds: nodeIdList,
+  }));
+
+  return {
+    version: "1.0.0",
+    runId,
+    team: manifest.team ?? "unknown",
+    workflow: manifest.workflow ?? "unknown",
+    createdAt: manifest.createdAt,
+    completedAt: manifest.updatedAt,
+    status: manifest.status,
+    nodes,
+    edges,
+    layers,
+  };
+}
+
+/**
+ * Save run graph to disk in .crew/graphs/
+ */
+export function saveRunGraph(graph: RunGraph, cwd: string): string {
+  const crewRoot = path.join(cwd, ".crew");
+  const graphsDir = path.join(crewRoot, "graphs");
+
+  if (!fs.existsSync(graphsDir)) {
+    fs.mkdirSync(graphsDir, { recursive: true });
+  }
+
+  const graphPath = path.join(graphsDir, `${graph.runId}.json`);
+  fs.writeFileSync(graphPath, JSON.stringify(graph, null, 2), "utf-8");
+
+  return graphPath;
+}
+
+/**
+ * Load run graph from disk.
+ */
+export function loadRunGraph(cwd: string, runId: string): RunGraph | null {
+  const graphPath = path.join(cwd, ".crew", "graphs", `${runId}.json`);
+  if (!fs.existsSync(graphPath)) return null;
+
+  try {
+    return JSON.parse(fs.readFileSync(graphPath, "utf-8")) as RunGraph;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * List all archived run graphs.
+ */
+export function listRunGraphs(cwd: string): string[] {
+  const graphsDir = path.join(cwd, ".crew", "graphs");
+  if (!fs.existsSync(graphsDir)) return [];
+
+  return fs.readdirSync(graphsDir)
+    .filter((f) => f.endsWith(".json"))
+    .map((f) => f.replace(/\.json$/, ""));
+}
+
+/**
+ * Build and save run graph from manifest + tasks.
+ */
+export function buildAndSaveRunGraph(
+  manifest: TeamRunManifest,
+  tasks: TeamTaskState[],
+  cwd: string,
+): string {
+  const graph = buildRunGraph(manifest, tasks);
+  return saveRunGraph(graph, cwd);
+}

package/src/utils/bm25-search.ts

@@ -0,0 +1,207 @@
+import type { AgentConfig } from "../agents/agent-config.ts";
+import type { TeamConfig } from "../teams/team-config.ts";
+
+interface SearchDocument {
+  id: string;
+  fields: Record<string, string>;
+}
+
+interface SearchResult<T> {
+  item: T;
+  score: number;
+  matchedOn: string[];
+}
+
+interface BM25Config {
+  k1?: number;
+  b?: number;
+}
+
+export class BM25Search<T extends SearchDocument> {
+  private readonly documents: T[];
+  private readonly fieldWeights: Record<string, number>;
+  private readonly avgDocLen: number;
+  private readonly k1: number;
+  private readonly b: number;
+  private readonly docLenMap: Map<string, number>;
+  private readonly N: number;
+
+  constructor(documents: T[], fieldWeights: Record<string, number> = {}, config: BM25Config = {}) {
+    this.documents = documents;
+    this.fieldWeights = fieldWeights;
+    this.k1 = config.k1 ?? 1.5;
+    this.b = config.b ?? 0.75;
+    this.N = documents.length;
+
+    this.docLenMap = new Map();
+
+    for (const doc of documents) {
+      const fieldValues = Object.values(doc.fields).join(" ");
+      const len = fieldValues.split(/\s+/).filter(Boolean).length;
+      this.docLenMap.set(doc.id, len);
+    }
+
+    const totalLen = [...this.docLenMap.values()].reduce((a, b) => a + b, 0);
+    this.avgDocLen = totalLen / this.N || 1;
+  }
+
+  /**
+   * Compute document frequency for a query term using substring matching,
+   * consistent with the regex-based tf computation in search().
+   */
+  private df(term: string): number {
+    const escaped = term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const re = new RegExp(escaped, "g");
+    let count = 0;
+    for (const doc of this.documents) {
+      for (const field of Object.keys(this.fieldWeights)) {
+        const text = (doc.fields[field] ?? "").toLowerCase();
+        if (re.test(text)) {
+          count++;
+          break;
+        }
+      }
+    }
+    return count;
+  }
+
+  search(query: string, options?: { limit?: number; minScore?: number }): SearchResult<T>[] {
+    const queryTerms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    if (queryTerms.length === 0) return [];
+
+    const results: SearchResult<T>[] = [];
+
+    for (const doc of this.documents) {
+      let totalScore = 0;
+      const matchedOn: string[] = [];
+
+      for (const [field, weight] of Object.entries(this.fieldWeights)) {
+        const text = doc.fields[field] ?? "";
+        const textLower = text.toLowerCase();
+        let fieldScore = 0;
+
+        for (const term of queryTerms) {
+          const escaped = term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+          const tf = (textLower.match(new RegExp(escaped, "g")) ?? []).length;
+          if (tf === 0) continue;
+
+          const df = this.df(term);
+          if (df === 0) continue;
+
+          const idf = Math.log((this.N - df + 0.5) / (df + 0.5) + 1);
+          const docLen = this.docLenMap.get(doc.id) ?? this.avgDocLen;
+          const numerator = tf * (this.k1 + 1);
+          const denominator = tf + this.k1 * (1 - this.b + this.b * docLen / this.avgDocLen);
+          fieldScore += idf * (numerator / denominator);
+
+          matchedOn.push(field);
+        }
+
+        totalScore += fieldScore * (weight || 1);
+      }
+
+      if (totalScore > 0) {
+        results.push({
+          item: doc,
+          score: totalScore,
+          matchedOn: [...new Set(matchedOn)],
+        });
+      }
+    }
+
+    results.sort((a, b) => b.score - a.score);
+
+    const limit = options?.limit ?? 10;
+    const minScore = options?.minScore ?? 0.01;
+
+    return results.filter((r) => r.score >= minScore).slice(0, limit);
+  }
+}
+
+// Agent search interface
+interface AgentSearchResult {
+  agent: AgentConfig;
+  score: number;
+  matchedOn: string[];
+}
+
+/**
+ * Search agents using BM25 ranking.
+ * Uses dynamic import to avoid ESM/CJS issues at module load time.
+ */
+export async function searchAgents(query: string, options?: { limit?: number }): Promise<AgentSearchResult[]> {
+  const { discoverAgents, allAgents } = await import("../agents/discover-agents.ts");
+  const discovery = discoverAgents(process.cwd());
+  const all = allAgents(discovery);
+
+  const docs: (SearchDocument & { agent: AgentConfig })[] = all.map((agent: AgentConfig) => ({
+    id: agent.name,
+    fields: {
+      name: agent.name,
+      description: agent.description ?? "",
+      skills: (agent.skills ?? []).join(" "),
+    },
+    agent,
+  }));
+
+  const engine = new BM25Search(docs, {
+    name: 3.0,
+    description: 1.5,
+    skills: 1.0,
+  });
+
+  const results = engine.search(query, {
+    limit: options?.limit ?? 10,
+    minScore: 0.1,
+  });
+
+  return results.map((r) => ({
+    agent: r.item.agent,
+    score: r.score,
+    matchedOn: r.matchedOn,
+  }));
+}
+
+// Team search interface
+interface TeamSearchResult {
+  team: TeamConfig;
+  score: number;
+  matchedOn: string[];
+}
+
+/**
+ * Search teams using BM25 ranking.
+ * Uses dynamic import to avoid ESM/CJS issues at module load time.
+ */
+export async function searchTeams(query: string, options?: { limit?: number }): Promise<TeamSearchResult[]> {
+  const { discoverTeams, allTeams } = await import("../teams/discover-teams.ts");
+  const discovery = discoverTeams(process.cwd());
+  const all = allTeams(discovery);
+
+  const docs: (SearchDocument & { team: TeamConfig })[] = all.map((team: TeamConfig) => ({
+    id: team.name,
+    fields: {
+      name: team.name,
+      description: team.description ?? "",
+      roles: (team.roles ?? []).map((r: { name: string }) => r.name).join(" "),
+    },
+    team,
+  }));
+
+  const engine = new BM25Search(docs, {
+    name: 2.0,
+    description: 1.5,
+    roles: 1.0,
+  });
+
+  const results = engine.search(query, {
+    limit: options?.limit ?? 5,
+    minScore: 0.1,
+  });
+
+  return results.map((r) => ({
+    team: r.item.team,
+    score: r.score,
+    matchedOn: r.matchedOn,
+  }));
+}