pi-messenger 0.7.3

package/crew/utils/config.ts

@@ -0,0 +1,104 @@
+/**
+ * Crew - Configuration Loading
+ * 
+ * Loads and merges user-level and project-level configuration.
+ */
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import type { MaxOutputConfig } from "./truncate.js";
+
+const USER_CONFIG_PATH = path.join(os.homedir(), ".pi", "agent", "pi-messenger.json");
+const PROJECT_CONFIG_FILE = "config.json";
+
+export interface CrewConfig {
+  concurrency: {
+    scouts: number;
+    workers: number;
+  };
+  truncation: {
+    scouts: MaxOutputConfig;
+    workers: MaxOutputConfig;
+    reviewers: MaxOutputConfig;
+    analysts: MaxOutputConfig;
+  };
+  artifacts: {
+    enabled: boolean;
+    cleanupDays: number;
+  };
+  memory: { enabled: boolean };
+  planSync: { enabled: boolean };
+  review: { enabled: boolean; maxIterations: number };
+  work: { maxAttemptsPerTask: number; maxWaves: number; stopOnBlock: boolean };
+}
+
+const DEFAULT_CONFIG: CrewConfig = {
+  concurrency: {
+    scouts: 4,
+    workers: 2,
+  },
+  truncation: {
+    scouts: { bytes: 51200, lines: 500 },
+    workers: { bytes: 204800, lines: 5000 },
+    reviewers: { bytes: 102400, lines: 2000 },
+    analysts: { bytes: 102400, lines: 2000 },
+  },
+  artifacts: { enabled: true, cleanupDays: 7 },
+  memory: { enabled: false },
+  planSync: { enabled: false },
+  review: { enabled: true, maxIterations: 3 },
+  work: { maxAttemptsPerTask: 5, maxWaves: 50, stopOnBlock: false },
+};
+
+function loadJson(filePath: string): Record<string, unknown> {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+function deepMerge<T extends object>(target: T, ...sources: Partial<T>[]): T {
+  const result = { ...target };
+  for (const source of sources) {
+    for (const key of Object.keys(source) as (keyof T)[]) {
+      const targetVal = result[key];
+      const sourceVal = source[key];
+      if (sourceVal && typeof sourceVal === "object" && !Array.isArray(sourceVal)) {
+        result[key] = deepMerge(targetVal as object, sourceVal as object) as T[keyof T];
+      } else if (sourceVal !== undefined) {
+        result[key] = sourceVal as T[keyof T];
+      }
+    }
+  }
+  return result;
+}
+
+/**
+ * Load crew configuration with priority: defaults <- user <- project
+ */
+export function loadCrewConfig(crewDir: string): CrewConfig {
+  // User-level config (from ~/.pi/agent/pi-messenger.json -> crew section)
+  const userConfig = loadJson(USER_CONFIG_PATH);
+  const userCrewConfig = (userConfig.crew ?? {}) as Partial<CrewConfig>;
+
+  // Project-level config (from .pi/messenger/crew/config.json)
+  const projectConfig = loadJson(path.join(crewDir, PROJECT_CONFIG_FILE)) as Partial<CrewConfig>;
+
+  // Merge: defaults <- user <- project
+  return deepMerge(DEFAULT_CONFIG, userCrewConfig, projectConfig);
+}
+
+/**
+ * Get truncation config for a specific role.
+ */
+export function getTruncationForRole(config: CrewConfig, role: string): MaxOutputConfig {
+  switch (role) {
+    case "scout": return config.truncation.scouts;
+    case "worker": return config.truncation.workers;
+    case "reviewer": return config.truncation.reviewers;
+    case "analyst": return config.truncation.analysts;
+    default: return config.truncation.workers;
+  }
+}

package/crew/utils/discover.ts

@@ -0,0 +1,170 @@
+/**
+ * Crew - Agent Discovery
+ * 
+ * Discovers agent definitions from user and project directories,
+ * with crew-specific filtering by role.
+ */
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import type { MaxOutputConfig } from "./truncate.js";
+
+export type CrewRole = "scout" | "worker" | "reviewer" | "analyst";
+
+export interface CrewAgentConfig {
+  name: string;
+  description: string;
+  tools?: string[];
+  model?: string;
+  systemPrompt: string;
+  source: "user" | "project";
+  filePath: string;
+  // Crew-specific extensions
+  crewRole?: CrewRole;
+  maxOutput?: MaxOutputConfig;
+  parallel?: boolean;
+  retryable?: boolean;
+}
+
+export interface AgentDiscoveryResult {
+  agents: CrewAgentConfig[];
+  projectAgentsDir: string | null;
+}
+
+/**
+ * Parse YAML-like frontmatter from markdown content.
+ */
+function parseFrontmatter(content: string): { frontmatter: Record<string, unknown>; body: string } {
+  const normalized = content.replace(/\r\n/g, "\n");
+  if (!normalized.startsWith("---")) {
+    return { frontmatter: {}, body: normalized };
+  }
+  const endIndex = normalized.indexOf("\n---", 3);
+  if (endIndex === -1) {
+    return { frontmatter: {}, body: normalized };
+  }
+  const frontmatterBlock = normalized.slice(4, endIndex);
+  const body = normalized.slice(endIndex + 4).trim();
+
+  const frontmatter: Record<string, unknown> = {};
+  for (const line of frontmatterBlock.split("\n")) {
+    const match = line.match(/^([\w-]+):\s*(.*)$/);
+    if (match) {
+      let value: unknown = match[2].trim();
+      // Handle quoted strings
+      if ((value as string).startsWith('"') || (value as string).startsWith("'")) {
+        value = (value as string).slice(1, -1);
+      }
+      // Handle inline YAML objects (e.g., maxOutput: { bytes: 1024, lines: 500 })
+      if ((value as string).startsWith("{") && (value as string).endsWith("}")) {
+        try {
+          // YAML inline objects don't require quoted keys, but JSON does
+          const jsonStr = (value as string).replace(/(\w+):/g, '"$1":');
+          value = JSON.parse(jsonStr);
+        } catch {
+          // Keep as string if parse fails
+        }
+      }
+      // Handle booleans
+      if (value === "true") value = true;
+      if (value === "false") value = false;
+      frontmatter[match[1]] = value;
+    }
+  }
+  return { frontmatter, body };
+}
+
+function isDirectory(p: string): boolean {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function findProjectAgentsDir(cwd: string): string | null {
+  let currentDir = cwd;
+  while (true) {
+    const candidate = path.join(currentDir, ".pi", "agents");
+    if (isDirectory(candidate)) return candidate;
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) return null;
+    currentDir = parentDir;
+  }
+}
+
+function loadAgentsFromDir(dir: string, source: "user" | "project"): CrewAgentConfig[] {
+  if (!fs.existsSync(dir)) return [];
+  const agents: CrewAgentConfig[] = [];
+
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.name.endsWith(".md")) continue;
+    if (!entry.isFile() && !entry.isSymbolicLink()) continue;
+
+    const filePath = path.join(dir, entry.name);
+    let content: string;
+    try {
+      content = fs.readFileSync(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const { frontmatter, body } = parseFrontmatter(content);
+
+    if (!frontmatter.name || !frontmatter.description) continue;
+
+    // Parse tools (comma-separated, filter empty)
+    const tools = (frontmatter.tools as string)
+      ?.split(",")
+      .map(t => t.trim())
+      .filter(Boolean);
+
+    agents.push({
+      name: frontmatter.name as string,
+      description: frontmatter.description as string,
+      tools: tools && tools.length > 0 ? tools : undefined,
+      model: frontmatter.model as string | undefined,
+      systemPrompt: body,
+      source,
+      filePath,
+      // Crew extensions
+      crewRole: frontmatter.crewRole as CrewRole | undefined,
+      maxOutput: frontmatter.maxOutput as MaxOutputConfig | undefined,
+      parallel: frontmatter.parallel as boolean | undefined ?? true,
+      retryable: frontmatter.retryable as boolean | undefined ?? true,
+    });
+  }
+  return agents;
+}
+
+/**
+ * Discover all agents from user and/or project directories.
+ */
+export function discoverAgents(cwd: string, scope: "user" | "project" | "both"): AgentDiscoveryResult {
+  const userDir = path.join(os.homedir(), ".pi", "agent", "agents");
+  const projectDir = findProjectAgentsDir(cwd);
+
+  const userAgents = scope !== "project" ? loadAgentsFromDir(userDir, "user") : [];
+  const projectAgents = scope !== "user" && projectDir ? loadAgentsFromDir(projectDir, "project") : [];
+
+  // Project overrides user (same name = project wins)
+  const agentMap = new Map<string, CrewAgentConfig>();
+  for (const a of userAgents) agentMap.set(a.name, a);
+  for (const a of projectAgents) agentMap.set(a.name, a);
+
+  return { agents: Array.from(agentMap.values()), projectAgentsDir: projectDir };
+}
+
+/**
+ * Discover only crew agents (those with crewRole set).
+ */
+export function discoverCrewAgents(cwd: string): CrewAgentConfig[] {
+  return discoverAgents(cwd, "both").agents.filter(a => a.crewRole !== undefined);
+}
+
+/**
+ * Get crew agents filtered by role.
+ */
+export function getAgentsByRole(cwd: string, role: CrewRole): CrewAgentConfig[] {
+  return discoverCrewAgents(cwd).filter(a => a.crewRole === role);
+}

package/crew/utils/install.ts

@@ -0,0 +1,373 @@
+/**
+ * Crew - Agent & Skill Installer
+ * 
+ * Copies crew agent definitions and skills from extension source to user directories.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+
+// Resolve paths relative to this file
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Agents: crew/agents/ -> ~/.pi/agent/agents/
+const SOURCE_AGENTS_DIR = path.resolve(__dirname, "..", "agents");
+const TARGET_AGENTS_DIR = path.join(homedir(), ".pi", "agent", "agents");
+
+// Skills: skills/ -> ~/.pi/agent/skills/
+const SOURCE_SKILLS_DIR = path.resolve(__dirname, "..", "..", "skills");
+const TARGET_SKILLS_DIR = path.join(homedir(), ".pi", "agent", "skills");
+
+// List of crew agents to install
+const CREW_AGENTS = [
+  // Scouts (5)
+  "crew-repo-scout.md",
+  "crew-practice-scout.md",
+  "crew-docs-scout.md",
+  "crew-web-scout.md",
+  "crew-github-scout.md",
+  // Analysts (3)
+  "crew-gap-analyst.md",
+  "crew-interview-generator.md",
+  "crew-plan-sync.md",
+  // Worker (1)
+  "crew-worker.md",
+  // Reviewer (1)
+  "crew-reviewer.md",
+];
+
+// List of skills to install (directory names)
+const CREW_SKILLS = [
+  "pi-messenger-crew",
+];
+
+export interface InstallResult {
+  installed: string[];
+  updated: string[];
+  skipped: string[];
+  errors: string[];
+  targetDir: string;
+}
+
+/**
+ * Check if an agent needs updating by comparing modification times.
+ */
+function needsUpdate(sourcePath: string, targetPath: string): boolean {
+  if (!fs.existsSync(targetPath)) return true;
+  
+  try {
+    const sourceStat = fs.statSync(sourcePath);
+    const targetStat = fs.statSync(targetPath);
+    return sourceStat.mtimeMs > targetStat.mtimeMs;
+  } catch {
+    return true;
+  }
+}
+
+/**
+ * Check which agents are missing or need updating.
+ */
+export function checkAgentStatus(): { missing: string[]; outdated: string[]; current: string[] } {
+  const missing: string[] = [];
+  const outdated: string[] = [];
+  const current: string[] = [];
+
+  for (const agent of CREW_AGENTS) {
+    const sourcePath = path.join(SOURCE_AGENTS_DIR, agent);
+    const targetPath = path.join(TARGET_AGENTS_DIR, agent);
+
+    if (!fs.existsSync(sourcePath)) {
+      // Source doesn't exist - skip
+      continue;
+    }
+
+    if (!fs.existsSync(targetPath)) {
+      missing.push(agent);
+    } else if (needsUpdate(sourcePath, targetPath)) {
+      outdated.push(agent);
+    } else {
+      current.push(agent);
+    }
+  }
+
+  return { missing, outdated, current };
+}
+
+/**
+ * Install or update crew agents.
+ * 
+ * @param force - If true, overwrite even if target is newer
+ */
+export function installAgents(force: boolean = false): InstallResult {
+  const result: InstallResult = {
+    installed: [],
+    updated: [],
+    skipped: [],
+    errors: [],
+    targetDir: TARGET_AGENTS_DIR,
+  };
+
+  // Ensure target directory exists
+  if (!fs.existsSync(TARGET_AGENTS_DIR)) {
+    try {
+      fs.mkdirSync(TARGET_AGENTS_DIR, { recursive: true });
+    } catch (err) {
+      result.errors.push(`Failed to create directory: ${TARGET_AGENTS_DIR}`);
+      return result;
+    }
+  }
+
+  for (const agent of CREW_AGENTS) {
+    const sourcePath = path.join(SOURCE_AGENTS_DIR, agent);
+    const targetPath = path.join(TARGET_AGENTS_DIR, agent);
+
+    // Check source exists
+    if (!fs.existsSync(sourcePath)) {
+      result.errors.push(`Source not found: ${agent}`);
+      continue;
+    }
+
+    // Check if we need to copy
+    const targetExists = fs.existsSync(targetPath);
+    const shouldUpdate = force || needsUpdate(sourcePath, targetPath);
+
+    if (!shouldUpdate) {
+      result.skipped.push(agent);
+      continue;
+    }
+
+    // Copy the file
+    try {
+      fs.copyFileSync(sourcePath, targetPath);
+      if (targetExists) {
+        result.updated.push(agent);
+      } else {
+        result.installed.push(agent);
+      }
+    } catch (err) {
+      result.errors.push(`Failed to copy ${agent}: ${err}`);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Uninstall crew agents (remove from target directory).
+ */
+export function uninstallAgents(): { removed: string[]; notFound: string[]; errors: string[] } {
+  const removed: string[] = [];
+  const notFound: string[] = [];
+  const errors: string[] = [];
+
+  for (const agent of CREW_AGENTS) {
+    const targetPath = path.join(TARGET_AGENTS_DIR, agent);
+
+    if (!fs.existsSync(targetPath)) {
+      notFound.push(agent);
+      continue;
+    }
+
+    try {
+      fs.unlinkSync(targetPath);
+      removed.push(agent);
+    } catch (err) {
+      errors.push(`Failed to remove ${agent}: ${err}`);
+    }
+  }
+
+  return { removed, notFound, errors };
+}
+
+/**
+ * Ensure agents are installed (auto-install if missing).
+ * Returns true if all agents are available.
+ */
+export function ensureAgentsInstalled(): boolean {
+  const status = checkAgentStatus();
+  
+  if (status.missing.length === 0 && status.outdated.length === 0) {
+    return true;
+  }
+
+  const result = installAgents();
+  return result.errors.length === 0;
+}
+
+/**
+ * Get the source agents directory path.
+ */
+export function getSourceAgentsDir(): string {
+  return SOURCE_AGENTS_DIR;
+}
+
+/**
+ * Get the target agents directory path.
+ */
+export function getTargetAgentsDir(): string {
+  return TARGET_AGENTS_DIR;
+}
+
+// =============================================================================
+// Skills Installation
+// =============================================================================
+
+export interface SkillInstallResult {
+  installed: string[];
+  updated: string[];
+  skipped: string[];
+  errors: string[];
+  targetDir: string;
+}
+
+/**
+ * Check if a skill directory needs updating.
+ */
+function skillNeedsUpdate(sourceDir: string, targetDir: string): boolean {
+  if (!fs.existsSync(targetDir)) return true;
+  
+  const skillFile = path.join(sourceDir, "SKILL.md");
+  const targetFile = path.join(targetDir, "SKILL.md");
+  
+  return needsUpdate(skillFile, targetFile);
+}
+
+/**
+ * Check which skills are missing or need updating.
+ */
+export function checkSkillStatus(): { missing: string[]; outdated: string[]; current: string[] } {
+  const missing: string[] = [];
+  const outdated: string[] = [];
+  const current: string[] = [];
+
+  for (const skill of CREW_SKILLS) {
+    const sourceDir = path.join(SOURCE_SKILLS_DIR, skill);
+    const targetDir = path.join(TARGET_SKILLS_DIR, skill);
+
+    if (!fs.existsSync(sourceDir)) {
+      continue;
+    }
+
+    if (!fs.existsSync(targetDir)) {
+      missing.push(skill);
+    } else if (skillNeedsUpdate(sourceDir, targetDir)) {
+      outdated.push(skill);
+    } else {
+      current.push(skill);
+    }
+  }
+
+  return { missing, outdated, current };
+}
+
+/**
+ * Install or update skills.
+ */
+export function installSkills(force: boolean = false): SkillInstallResult {
+  const result: SkillInstallResult = {
+    installed: [],
+    updated: [],
+    skipped: [],
+    errors: [],
+    targetDir: TARGET_SKILLS_DIR,
+  };
+
+  // Ensure target directory exists
+  if (!fs.existsSync(TARGET_SKILLS_DIR)) {
+    try {
+      fs.mkdirSync(TARGET_SKILLS_DIR, { recursive: true });
+    } catch (err) {
+      result.errors.push(`Failed to create directory: ${TARGET_SKILLS_DIR}`);
+      return result;
+    }
+  }
+
+  for (const skill of CREW_SKILLS) {
+    const sourceDir = path.join(SOURCE_SKILLS_DIR, skill);
+    const targetDir = path.join(TARGET_SKILLS_DIR, skill);
+
+    if (!fs.existsSync(sourceDir)) {
+      result.errors.push(`Source not found: ${skill}`);
+      continue;
+    }
+
+    const targetExists = fs.existsSync(targetDir);
+    const shouldUpdate = force || skillNeedsUpdate(sourceDir, targetDir);
+
+    if (!shouldUpdate) {
+      result.skipped.push(skill);
+      continue;
+    }
+
+    try {
+      // Create target directory
+      if (!targetExists) {
+        fs.mkdirSync(targetDir, { recursive: true });
+      }
+
+      // Copy all files from skill directory
+      const files = fs.readdirSync(sourceDir);
+      for (const file of files) {
+        const srcFile = path.join(sourceDir, file);
+        const dstFile = path.join(targetDir, file);
+        if (fs.statSync(srcFile).isFile()) {
+          fs.copyFileSync(srcFile, dstFile);
+        }
+      }
+
+      if (targetExists) {
+        result.updated.push(skill);
+      } else {
+        result.installed.push(skill);
+      }
+    } catch (err) {
+      result.errors.push(`Failed to copy ${skill}: ${err}`);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Uninstall skills.
+ */
+export function uninstallSkills(): { removed: string[]; notFound: string[]; errors: string[] } {
+  const removed: string[] = [];
+  const notFound: string[] = [];
+  const errors: string[] = [];
+
+  for (const skill of CREW_SKILLS) {
+    const targetDir = path.join(TARGET_SKILLS_DIR, skill);
+
+    if (!fs.existsSync(targetDir)) {
+      notFound.push(skill);
+      continue;
+    }
+
+    try {
+      fs.rmSync(targetDir, { recursive: true });
+      removed.push(skill);
+    } catch (err) {
+      errors.push(`Failed to remove ${skill}: ${err}`);
+    }
+  }
+
+  return { removed, notFound, errors };
+}
+
+/**
+ * Ensure skills are installed (auto-install if missing).
+ */
+export function ensureSkillsInstalled(): boolean {
+  const status = checkSkillStatus();
+  
+  if (status.missing.length === 0 && status.outdated.length === 0) {
+    return true;
+  }
+
+  const result = installSkills();
+  return result.errors.length === 0;
+}