@cuylabs/agent-core 0.7.0 → 0.9.0

package/dist/{chunk-7MUFEN4K.js → chunk-JLXG2SH7.js}

@@ -1,6 +1,9 @@
+import {
+  Presets
+} from "./chunk-EKR6PKXU.js";
 import {
   Tool
-} from "./chunk-P6YF7USR.js";
+} from "./chunk-MHKK374K.js";
 
 // src/sub-agent/types.ts
 var DEFAULT_MAX_CONCURRENT = 6;
@@ -169,7 +172,7 @@ var SubAgentTracker = class {
     }
     if (timeoutMs !== void 0 && timeoutMs > 0) {
       const timeout = new Promise(
-        (resolve) => setTimeout(() => resolve({ timedOut: true }), timeoutMs)
+        (resolve2) => setTimeout(() => resolve2({ timedOut: true }), timeoutMs)
       );
       return Promise.race([...races, timeout]);
     }
@@ -550,10 +553,353 @@ function createSubAgentTools(parent, config) {
   return tools;
 }
 
+// src/sub-agent/markdown-profile.ts
+var FRONTMATTER_REGEX = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
+var VALID_REASONING_LEVELS = /* @__PURE__ */ new Set([
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh"
+]);
+function parseAgentFrontmatter(raw) {
+  const result = {};
+  const lines = raw.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trim() === "" || line.trim().startsWith("#")) {
+      i++;
+      continue;
+    }
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) {
+      i++;
+      continue;
+    }
+    const key = line.slice(0, colonIndex).trim();
+    let value = line.slice(colonIndex + 1).trim();
+    if (value === "|") {
+      const blockLines = [];
+      i++;
+      while (i < lines.length) {
+        const blockLine = lines[i];
+        if (blockLine.length > 0 && !blockLine.startsWith(" ") && !blockLine.startsWith("	")) {
+          break;
+        }
+        blockLines.push(blockLine);
+        i++;
+      }
+      const minIndent = blockLines.filter((l) => l.trim().length > 0).reduce((min, l) => {
+        const indent = l.match(/^(\s*)/)?.[1].length ?? 0;
+        return Math.min(min, indent);
+      }, Infinity);
+      result[key] = blockLines.map((l) => l.trim().length === 0 ? "" : l.slice(minIndent)).join("\n").trim();
+      continue;
+    }
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key.length > 0) {
+      result[key] = value;
+    }
+    i++;
+  }
+  return result;
+}
+function parseMarkdownAgent(content, filePath) {
+  const match = content.match(FRONTMATTER_REGEX);
+  if (!match) {
+    return null;
+  }
+  const [, rawFrontmatter, body] = match;
+  const fields = parseAgentFrontmatter(rawFrontmatter);
+  if (!fields.name || !fields.description) {
+    return null;
+  }
+  const frontmatter = {
+    name: fields.name,
+    description: fields.description
+  };
+  if (fields.preset) frontmatter.preset = fields.preset;
+  if (fields.extends) frontmatter.extends = fields.extends;
+  if (fields.model) frontmatter.model = fields.model;
+  if (fields.maxSteps) frontmatter.maxSteps = fields.maxSteps;
+  if (fields.temperature) frontmatter.temperature = fields.temperature;
+  if (fields.reasoning) frontmatter.reasoning = fields.reasoning;
+  if (fields.tools) frontmatter.tools = fields.tools;
+  if (fields.skills) frontmatter.skills = fields.skills;
+  if (fields.canSpawn) frontmatter.canSpawn = fields.canSpawn;
+  return {
+    frontmatter,
+    body: body.trim(),
+    filePath
+  };
+}
+function parseToolSpec(raw) {
+  if (raw === void 0 || raw.trim() === "") {
+    return { mode: "inherit" };
+  }
+  const items = raw.split(",").map((s) => s.trim()).filter(Boolean);
+  if (items.length === 0) {
+    return { mode: "inherit" };
+  }
+  const hasModifiers = items.some((item) => item.startsWith("+") || item.startsWith("-"));
+  if (hasModifiers) {
+    const modifiers = items.map((item) => {
+      if (item.startsWith("+")) {
+        return { kind: "add", pattern: item.slice(1) };
+      }
+      if (item.startsWith("-")) {
+        return { kind: "remove", pattern: item.slice(1) };
+      }
+      return { kind: "add", pattern: item };
+    });
+    return { mode: "modifiers", modifiers };
+  }
+  return { mode: "explicit", patterns: items };
+}
+function toAgentProfile(parsed, resolvers = {}) {
+  const { frontmatter, body } = parsed;
+  const parent = frontmatter.extends ? resolvers.resolveParent?.(frontmatter.extends) : void 0;
+  const preset = frontmatter.preset ? resolvers.resolvePreset?.(frontmatter.preset) : parent?.preset;
+  let systemPrompt;
+  if (body.length > 0) {
+    const parentPrompt = parent?.systemPrompt ?? preset?.systemPrompt ?? "";
+    systemPrompt = body.includes("{basePrompt}") ? body.replace("{basePrompt}", parentPrompt) : body;
+  } else if (parent?.systemPrompt) {
+    systemPrompt = parent.systemPrompt;
+  }
+  const maxSteps = frontmatter.maxSteps ? parseInt(frontmatter.maxSteps, 10) : parent?.maxSteps;
+  let resolvedPreset = preset;
+  const temperature = frontmatter.temperature ? parseFloat(frontmatter.temperature) : void 0;
+  const reasoning = frontmatter.reasoning;
+  if (temperature !== void 0 || reasoning !== void 0) {
+    resolvedPreset = {
+      ...preset ?? { name: "custom", description: "Markdown-defined agent" },
+      ...temperature !== void 0 ? { temperature } : {},
+      ...reasoning !== void 0 && VALID_REASONING_LEVELS.has(reasoning) ? { reasoningLevel: reasoning } : {}
+    };
+  }
+  const toolSpec = parseToolSpec(frontmatter.tools);
+  if (toolSpec.mode === "explicit" || toolSpec.mode === "modifiers") {
+    resolvedPreset = {
+      ...resolvedPreset ?? { name: "custom", description: "Markdown-defined agent" }
+    };
+    if (toolSpec.mode === "explicit") {
+      resolvedPreset.allowTools = toolSpec.patterns;
+      resolvedPreset.denyTools = void 0;
+    } else {
+      const baseAllow = [...resolvedPreset.allowTools ?? []];
+      const baseDeny = [...resolvedPreset.denyTools ?? []];
+      for (const mod of toolSpec.modifiers) {
+        if (mod.kind === "add") {
+          baseAllow.push(mod.pattern);
+          const denyIdx = baseDeny.indexOf(mod.pattern);
+          if (denyIdx !== -1) baseDeny.splice(denyIdx, 1);
+        } else {
+          baseDeny.push(mod.pattern);
+          const allowIdx = baseAllow.indexOf(mod.pattern);
+          if (allowIdx !== -1) baseAllow.splice(allowIdx, 1);
+        }
+      }
+      if (baseAllow.length > 0) resolvedPreset.allowTools = baseAllow;
+      if (baseDeny.length > 0) resolvedPreset.denyTools = baseDeny;
+    }
+  }
+  const canSpawn = frontmatter.canSpawn ? frontmatter.canSpawn === "true" : parent?.canSpawn;
+  const profile = {
+    name: frontmatter.name,
+    description: frontmatter.description
+  };
+  if (resolvedPreset) profile.preset = resolvedPreset;
+  if (systemPrompt) profile.systemPrompt = systemPrompt;
+  if (maxSteps !== void 0 && !isNaN(maxSteps)) profile.maxSteps = maxSteps;
+  if (canSpawn !== void 0) profile.canSpawn = canSpawn;
+  if (frontmatter.model) {
+    profile._modelId = frontmatter.model;
+  }
+  if (frontmatter.skills) {
+    profile._skillNames = frontmatter.skills.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  profile._source = parsed.filePath;
+  return profile;
+}
+function isMarkdownProfile(profile) {
+  return "_source" in profile;
+}
+
+// src/sub-agent/discovery.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { homedir } from "os";
+import { join, isAbsolute, resolve } from "path";
+var DEFAULT_USER_DIR = join(homedir(), ".cuylabs", "agents");
+var DEFAULT_PROJECT_DIR = ".cuylabs/agents";
+var PRESET_MAP = {
+  explore: Presets.explore,
+  plan: Presets.plan,
+  review: Presets.review,
+  quick: Presets.quick,
+  careful: Presets.careful,
+  code: Presets.code,
+  watch: Presets.watch
+};
+function defaultResolvePreset(name) {
+  return PRESET_MAP[name.toLowerCase()];
+}
+function isLoadableMarkdown(filename) {
+  return filename.endsWith(".md") && !filename.startsWith("_") && !filename.startsWith(".");
+}
+function loadAgentDir(dir, source, resolvers, errors) {
+  if (!existsSync(dir)) return [];
+  let stat;
+  try {
+    stat = statSync(dir);
+  } catch {
+    return [];
+  }
+  if (!stat.isDirectory()) return [];
+  const results = [];
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  for (const entry of entries) {
+    if (!entry.isFile() && !entry.isSymbolicLink()) continue;
+    if (!isLoadableMarkdown(entry.name)) continue;
+    const filePath = join(dir, entry.name);
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      const parsed = parseMarkdownAgent(content, filePath);
+      if (!parsed) {
+        errors.push({ path: filePath, error: "Missing required frontmatter (name, description)" });
+        continue;
+      }
+      const profile = toAgentProfile(parsed, resolvers);
+      results.push({ profile, source, filePath });
+    } catch (err) {
+      errors.push({
+        path: filePath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return results;
+}
+function loadAgentFile(filePath, source, resolvers, errors) {
+  if (!existsSync(filePath)) {
+    errors.push({ path: filePath, error: "File not found" });
+    return null;
+  }
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const parsed = parseMarkdownAgent(content, filePath);
+    if (!parsed) {
+      errors.push({ path: filePath, error: "Missing required frontmatter (name, description)" });
+      return null;
+    }
+    const profile = toAgentProfile(parsed, resolvers);
+    return { profile, source, filePath };
+  } catch (err) {
+    errors.push({
+      path: filePath,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return null;
+  }
+}
+function discoverAgentProfiles(options) {
+  const {
+    cwd,
+    userDir = DEFAULT_USER_DIR,
+    projectDir = DEFAULT_PROJECT_DIR,
+    configPaths = [],
+    builtInProfiles = [],
+    resolvePreset: customResolvePreset
+  } = options;
+  const errors = [];
+  const discovered = [];
+  const presetResolver = customResolvePreset ?? defaultResolvePreset;
+  const firstPassResolvers = {
+    resolvePreset: presetResolver
+    // resolveParent deferred to merge phase
+  };
+  for (const profile of builtInProfiles) {
+    discovered.push({ profile, source: "builtin" });
+  }
+  const userProfiles = loadAgentDir(userDir, "user", firstPassResolvers, errors);
+  discovered.push(...userProfiles);
+  const projectAgentsDir = resolve(cwd, projectDir);
+  const projectProfiles = loadAgentDir(projectAgentsDir, "project", firstPassResolvers, errors);
+  discovered.push(...projectProfiles);
+  for (const configPath of configPaths) {
+    const resolved = isAbsolute(configPath) ? configPath : resolve(cwd, configPath);
+    const entry = loadAgentFile(resolved, "config", firstPassResolvers, errors);
+    if (entry) discovered.push(entry);
+  }
+  const profileMap = /* @__PURE__ */ new Map();
+  for (const entry of discovered) {
+    profileMap.set(entry.profile.name, entry);
+  }
+  const merged = /* @__PURE__ */ new Map();
+  for (const [name, entry] of profileMap) {
+    const profile = entry.profile;
+    const md = profile;
+    if ("_source" in md) {
+    }
+    merged.set(name, profile);
+  }
+  const allProfiles = merged;
+  for (const [name, entry] of profileMap) {
+    const profile = entry.profile;
+    if (!("_source" in profile)) continue;
+    const md = profile;
+    if (!md._source) continue;
+    try {
+      const content = readFileSync(md._source, "utf-8");
+      const parsed = parseMarkdownAgent(content, md._source);
+      if (parsed?.frontmatter.extends) {
+        const parentName = parsed.frontmatter.extends;
+        const parent = allProfiles.get(parentName);
+        if (parent) {
+          const resolvedProfile = toAgentProfile(parsed, {
+            resolvePreset: presetResolver,
+            resolveParent: (n) => allProfiles.get(n)
+          });
+          merged.set(name, resolvedProfile);
+        }
+      }
+    } catch {
+    }
+  }
+  return {
+    profiles: Array.from(merged.values()),
+    discovered: Array.from(profileMap.values()),
+    errors
+  };
+}
+function getUserAgentsDir() {
+  return DEFAULT_USER_DIR;
+}
+function getProjectAgentsDir(cwd) {
+  return resolve(cwd, DEFAULT_PROJECT_DIR);
+}
+
 export {
   DEFAULT_MAX_CONCURRENT,
   DEFAULT_MAX_SPAWN_DEPTH,
   DEFAULT_SESSION_TITLE_PREFIX,
   SubAgentTracker,
-  createSubAgentTools
+  createSubAgentTools,
+  parseAgentFrontmatter,
+  parseMarkdownAgent,
+  parseToolSpec,
+  toAgentProfile,
+  isMarkdownProfile,
+  discoverAgentProfiles,
+  getUserAgentsDir,
+  getProjectAgentsDir
 };