@cuylabs/agent-core 0.4.0 → 0.6.0

package/dist/chunk-DWYX7ASF.js

@@ -0,0 +1,26 @@
+// src/models/identifiers.ts
+function getModelId(model) {
+  if (typeof model === "string") return model;
+  if (typeof model === "object" && model !== null && "modelId" in model) {
+    return String(model.modelId);
+  }
+  return String(model);
+}
+function getProviderId(model) {
+  if (typeof model === "string") {
+    if (model.includes("/")) {
+      return model.split("/")[0];
+    }
+    return void 0;
+  }
+  if (typeof model === "object" && model !== null && "provider" in model) {
+    const provider = String(model.provider);
+    return provider.split(".")[0];
+  }
+  return void 0;
+}
+
+export {
+  getModelId,
+  getProviderId
+};

package/dist/chunk-FG4MD5MU.js

@@ -0,0 +1,54 @@
+import {
+  extractFilePathsFromArgs,
+  shouldCaptureBaseline
+} from "./chunk-VEKUXUVF.js";
+
+// src/tool/executor.ts
+async function executeAgentToolCall(options) {
+  const initialized = await options.tool.init({ cwd: options.cwd });
+  const ctx = {
+    cwd: options.cwd,
+    abort: options.abort,
+    sessionID: options.sessionID,
+    messageID: options.messageID,
+    agent: options.agent ?? "default",
+    ...options.host ? { host: options.host } : {},
+    ...options.turnTracker ? { turnTracker: options.turnTracker } : {}
+  };
+  if (options.middleware?.hasMiddleware) {
+    const decision = await options.middleware.runBeforeToolCall(
+      options.toolName,
+      options.params,
+      ctx
+    );
+    if (decision.action === "deny") {
+      return {
+        output: decision.reason ?? `Tool call denied: ${options.toolName}`
+      };
+    }
+  }
+  if (options.turnTracker && initialized.fileOps && shouldCaptureBaseline(initialized.fileOps)) {
+    const paths = extractFilePathsFromArgs(
+      options.params,
+      initialized.fileOps
+    );
+    for (const path of paths) {
+      await options.turnTracker.beforeWrite(path);
+    }
+  }
+  const result = await initialized.execute(options.params, ctx);
+  if (options.middleware?.hasMiddleware) {
+    const transformed = await options.middleware.runAfterToolCall(
+      options.toolName,
+      options.params,
+      result,
+      ctx
+    );
+    return { output: transformed.output };
+  }
+  return { output: result.output };
+}
+
+export {
+  executeAgentToolCall
+};

package/dist/chunk-IVUJDISU.js

@@ -0,0 +1,556 @@
+import {
+  createSkillRegistry,
+  emptySkillRegistry
+} from "./chunk-LRHOS4ZN.js";
+
+// src/prompt/templates.ts
+function extractModelId(model) {
+  if (typeof model === "string") return model;
+  if (typeof model === "object" && model !== null && "modelId" in model) {
+    return String(model.modelId);
+  }
+  return void 0;
+}
+function extractProvider(model) {
+  if (typeof model === "object" && model !== null && "provider" in model) {
+    return String(model.provider);
+  }
+  return void 0;
+}
+function detectModelFamily(model) {
+  const provider = extractProvider(model);
+  const modelId = extractModelId(model);
+  if (provider) {
+    const p = provider.toLowerCase();
+    if (p.startsWith("anthropic")) return "anthropic";
+    if (p.startsWith("openai") || p.startsWith("azure")) return "openai";
+    if (p.startsWith("google") || p.startsWith("vertex")) return "google";
+    if (p.startsWith("deepseek")) return "deepseek";
+  }
+  if (modelId) {
+    const id = modelId.toLowerCase();
+    if (/claude/.test(id)) return "anthropic";
+    if (/gpt|o1-|o3-|o4-|chatgpt/.test(id)) return "openai";
+    if (/gemini|palm/.test(id)) return "google";
+    if (/deepseek/.test(id)) return "deepseek";
+  }
+  return "default";
+}
+var TEMPLATE_ANTHROPIC = `You are a capable AI assistant with access to tools.
+
+<approach>
+- Think through problems carefully before taking action
+- Break complex tasks into smaller, verifiable steps
+- Gather context and information before making decisions
+- If uncertain, investigate first rather than guessing
+- Verify results after each action
+</approach>
+
+<tool-usage>
+- Use the tools available to you to accomplish tasks
+- Choose the most appropriate tool for each step
+- Review tool output before proceeding to the next step
+- If a tool fails, try an alternative approach \u2014 do not give up after one error
+- Keep iterating until the task is fully resolved or all options are exhausted
+</tool-usage>
+
+<communication>
+- Be concise and direct in responses
+- Explain the reasoning behind important decisions
+- If a task cannot be completed, explain clearly what's blocking it
+- Proactively mention potential issues or risks
+</communication>`;
+var TEMPLATE_OPENAI = `You are a capable AI assistant with access to tools.
+
+## Approach
+1. Think through problems step by step before acting
+2. Break complex tasks into smaller steps and validate each one
+3. Gather context and information before making decisions
+4. When uncertain, investigate rather than guess
+5. Verify results after each action
+
+## Tool Usage
+1. Use the most appropriate tool for each step
+2. Review tool output before proceeding
+3. If a tool fails, try an alternative approach \u2014 do not give up after one error
+4. Combine tools effectively to accomplish complex tasks
+5. Keep iterating until the task is fully resolved or all options are exhausted
+
+## Communication
+- Be direct and concise
+- Explain your reasoning for important decisions
+- Flag potential issues or risks proactively
+- If blocked, explain clearly what's needed`;
+var TEMPLATE_GOOGLE = `You are a capable AI assistant with access to tools.
+
+**Approach:**
+- Think through problems carefully before taking action
+- Break complex tasks into smaller, verifiable steps
+- Gather context before making decisions
+- When uncertain, investigate rather than guess
+- Verify results after each action
+
+**Tool Usage:**
+- Choose the most appropriate tool for each step
+- Review tool output before proceeding
+- If a tool fails, try an alternative approach \u2014 do not give up after one error
+- Keep iterating until the task is fully resolved or all options are exhausted
+
+**Communication:**
+- Be concise and direct
+- Explain your reasoning for important decisions
+- Proactively mention potential issues or risks`;
+var TEMPLATE_DEEPSEEK = `You are a capable AI assistant with access to tools.
+
+Principles:
+- Reason carefully before taking action
+- Break complex tasks into smaller steps
+- Gather context and verify assumptions
+- Use tools effectively \u2014 choose the right one for each step
+- If a tool fails, try an alternative \u2014 do not give up after one error
+- Keep iterating until the task is fully resolved
+- Verify results after each action
+
+Communication:
+- Be concise and direct
+- Focus on reasoning and results
+- Flag risks or issues proactively`;
+var TEMPLATE_DEFAULT = `You are a capable AI assistant with access to tools.
+
+Guidelines:
+- Think through problems step by step before taking action
+- Break complex tasks into smaller, verifiable steps
+- Gather context and information before making decisions
+- Use the most appropriate tool for each step
+- If a tool fails, try an alternative \u2014 do not give up after one error
+- Keep iterating until the task is fully resolved or all options are exhausted
+- Verify results after each action
+- Be concise and direct in communication
+- Proactively mention potential issues or risks`;
+var TEMPLATES = {
+  anthropic: TEMPLATE_ANTHROPIC,
+  openai: TEMPLATE_OPENAI,
+  google: TEMPLATE_GOOGLE,
+  deepseek: TEMPLATE_DEEPSEEK,
+  default: TEMPLATE_DEFAULT
+};
+function getTemplate(family) {
+  return TEMPLATES[family] ?? TEMPLATES.default;
+}
+function getAvailableFamilies() {
+  return Object.keys(TEMPLATES);
+}
+
+// src/prompt/environment.ts
+import { execSync } from "child_process";
+import { platform, arch } from "os";
+import { basename, resolve } from "path";
+function runQuiet(command, cwd) {
+  try {
+    return execSync(command, {
+      cwd,
+      encoding: "utf-8",
+      timeout: 3e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return void 0;
+  }
+}
+function formatPlatform() {
+  const os = platform();
+  const cpu = arch();
+  const names = {
+    darwin: "macOS",
+    linux: "Linux",
+    win32: "Windows",
+    freebsd: "FreeBSD"
+  };
+  return `${names[os] ?? os} (${os} ${cpu})`;
+}
+function formatDate() {
+  const now = /* @__PURE__ */ new Date();
+  return now.toLocaleDateString("en-US", {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone
+  });
+}
+function gatherEnvironment(cwd) {
+  const resolvedCwd = resolve(cwd);
+  const gitBranch = runQuiet("git branch --show-current", resolvedCwd);
+  const gitStatus = runQuiet("git status --porcelain", resolvedCwd);
+  const gitRoot = runQuiet("git rev-parse --show-toplevel", resolvedCwd);
+  return {
+    cwd: resolvedCwd,
+    platform: formatPlatform(),
+    date: formatDate(),
+    shell: process.env.SHELL ?? process.env.COMSPEC,
+    gitBranch: gitBranch || void 0,
+    gitClean: gitStatus !== void 0 ? gitStatus.length === 0 : void 0,
+    gitRoot: gitRoot || void 0
+  };
+}
+function formatEnvironment(info) {
+  const lines = [];
+  lines.push("<workspace>");
+  lines.push(`Directory: ${info.cwd}`);
+  lines.push(`Project: ${basename(info.cwd)}`);
+  lines.push(`Platform: ${info.platform}`);
+  lines.push(`Date: ${info.date}`);
+  if (info.shell) {
+    lines.push(`Shell: ${info.shell}`);
+  }
+  if (info.gitBranch) {
+    const status = info.gitClean ? "clean" : "uncommitted changes";
+    lines.push(`Git: ${info.gitBranch} (${status})`);
+  }
+  lines.push("</workspace>");
+  return lines.join("\n");
+}
+function summarizeEnvironment(info) {
+  const parts = [basename(info.cwd)];
+  if (info.gitBranch) parts.push(`[${info.gitBranch}]`);
+  parts.push(info.platform);
+  return parts.join(" \xB7 ");
+}
+
+// src/prompt/instructions.ts
+import { readFile, stat, access } from "fs/promises";
+import { dirname, join, resolve as resolve2, basename as basename2, sep } from "path";
+import { homedir } from "os";
+var DEFAULT_INSTRUCTION_PATTERNS = [
+  "AGENTS.md",
+  "CLAUDE.md",
+  "COPILOT.md",
+  ".cuylabs/instructions.md"
+];
+var DEFAULT_MAX_FILE_SIZE = 51200;
+var DEFAULT_MAX_DEPTH = 10;
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readInstructionFile(path, maxSize) {
+  try {
+    const info = await stat(path);
+    if (!info.isFile() || info.size > maxSize) return void 0;
+    const content = await readFile(path, "utf-8");
+    return content.trim();
+  } catch {
+    return void 0;
+  }
+}
+async function findGitRoot(startDir) {
+  let dir = resolve2(startDir);
+  const root = sep === "/" ? "/" : dir.slice(0, 3);
+  while (dir !== root && dir !== homedir()) {
+    if (await fileExists(join(dir, ".git"))) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+}
+async function discoverInstructions(cwd, patterns = DEFAULT_INSTRUCTION_PATTERNS, options) {
+  const maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+  const maxSize = options?.maxFileSize ?? DEFAULT_MAX_FILE_SIZE;
+  const stopAtGit = options?.stopAtGitRoot ?? false;
+  const resolvedCwd = resolve2(cwd);
+  const home = homedir();
+  const root = sep === "/" ? "/" : resolvedCwd.slice(0, 3);
+  const gitRoot = await findGitRoot(resolvedCwd);
+  const found = [];
+  let currentDir = resolvedCwd;
+  let depth = 0;
+  while (depth <= maxDepth) {
+    if (currentDir === home || currentDir === root) break;
+    if (stopAtGit && gitRoot && currentDir === dirname(gitRoot)) break;
+    for (const pattern of patterns) {
+      const filePath = join(currentDir, pattern);
+      const content = await readInstructionFile(filePath, maxSize);
+      if (content && content.length > 0) {
+        let source;
+        if (depth === 0) {
+          source = "project";
+        } else if (gitRoot && currentDir === gitRoot) {
+          source = "workspace";
+        } else {
+          source = "workspace";
+        }
+        found.push({ path: filePath, content, source, depth });
+      }
+    }
+    const parent = dirname(currentDir);
+    if (parent === currentDir) break;
+    currentDir = parent;
+    depth++;
+  }
+  found.reverse();
+  return found;
+}
+async function loadGlobalInstructions(paths, maxSize = DEFAULT_MAX_FILE_SIZE) {
+  const results = [];
+  for (const filePath of paths) {
+    const content = await readInstructionFile(resolve2(filePath), maxSize);
+    if (content && content.length > 0) {
+      results.push({
+        path: resolve2(filePath),
+        content,
+        source: "global",
+        depth: -1
+        // global = before all local files
+      });
+    }
+  }
+  return results;
+}
+function formatInstructions(files, basePath) {
+  if (files.length === 0) return "";
+  const blocks = [];
+  blocks.push("<project-instructions>");
+  for (const file of files) {
+    const displayPath = basePath ? file.path.replace(basePath + sep, "").replace(basePath, "") : basename2(file.path);
+    blocks.push("");
+    blocks.push(`<instructions source="${displayPath}" scope="${file.source}">`);
+    blocks.push(file.content);
+    blocks.push("</instructions>");
+  }
+  blocks.push("");
+  blocks.push("</project-instructions>");
+  return blocks.join("\n");
+}
+
+// src/prompt/builder/priorities.ts
+var PRIORITY_BASE = 10;
+var PRIORITY_ENVIRONMENT = 20;
+var PRIORITY_INSTRUCTIONS = 30;
+var PRIORITY_CUSTOM = 50;
+var PRIORITY_SKILLS = 70;
+var PRIORITY_OVERRIDE = 90;
+
+// src/prompt/builder/sections.ts
+async function composePromptSections(options) {
+  const { config, context, customSections, middleware, sources } = options;
+  const sections = [];
+  const family = config.modelFamily ?? detectModelFamily(context.model);
+  const templateContent = config.baseTemplate ?? getTemplate(family);
+  sections.push({
+    id: "base",
+    label: "Base Template",
+    content: templateContent,
+    priority: PRIORITY_BASE
+  });
+  if (config.includeEnvironment) {
+    const envInfo = sources.getEnvironment(context.cwd);
+    sections.push({
+      id: "environment",
+      label: "Environment",
+      content: formatEnvironment(envInfo),
+      priority: PRIORITY_ENVIRONMENT
+    });
+  }
+  if (config.includeInstructions) {
+    const instructionFiles = await sources.getInstructions(context.cwd);
+    if (instructionFiles.length > 0) {
+      sections.push({
+        id: "instructions",
+        label: "Project Instructions",
+        content: formatInstructions(instructionFiles, context.cwd),
+        priority: PRIORITY_INSTRUCTIONS
+      });
+    }
+  }
+  if (config.skills) {
+    const registry = await sources.getSkillRegistry(context.cwd);
+    const summary = registry.formatSummary();
+    if (summary.length > 0) {
+      sections.push({
+        id: "skills",
+        label: "Available Skills",
+        content: summary,
+        priority: PRIORITY_SKILLS
+      });
+    }
+  }
+  for (const section of customSections) {
+    sections.push(section);
+  }
+  if (middleware?.hasMiddleware) {
+    sections.push(...middleware.collectPromptSections(context));
+  }
+  if (context.override) {
+    sections.push({
+      id: "override",
+      label: "Additional Context",
+      content: context.override,
+      priority: PRIORITY_OVERRIDE
+    });
+  }
+  sections.sort(
+    (left, right) => (left.priority ?? PRIORITY_CUSTOM) - (right.priority ?? PRIORITY_CUSTOM)
+  );
+  return sections;
+}
+async function previewPromptSections(options) {
+  const sections = await composePromptSections(options);
+  return sections.filter((section) => section.enabled !== false).map((section) => ({
+    id: section.id,
+    label: section.label,
+    priority: section.priority ?? PRIORITY_CUSTOM,
+    size: section.content.length
+  }));
+}
+
+// src/prompt/builder/builder.ts
+var PromptBuilder = class {
+  config;
+  customSections = /* @__PURE__ */ new Map();
+  envCache;
+  instructionCache;
+  skillRegistryCache;
+  constructor(config) {
+    this.config = {
+      includeEnvironment: true,
+      includeInstructions: true,
+      separator: "\n\n",
+      ...config
+    };
+    if (config?.sections) {
+      for (const section of config.sections) {
+        this.customSections.set(section.id, section);
+      }
+    }
+  }
+  async build(context, middleware) {
+    const sections = await composePromptSections({
+      config: this.config,
+      context,
+      customSections: this.customSections.values(),
+      middleware,
+      sources: {
+        getEnvironment: (cwd) => this.getEnvironment(cwd),
+        getInstructions: (cwd) => this.getInstructions(cwd),
+        getSkillRegistry: (cwd) => this.getSkillRegistry(cwd)
+      }
+    });
+    return sections.filter((section) => section.enabled !== false).map((section) => section.content).filter((content) => content.length > 0).join(this.config.separator);
+  }
+  addSection(section) {
+    this.customSections.set(section.id, section);
+  }
+  removeSection(id) {
+    return this.customSections.delete(id);
+  }
+  toggleSection(id, enabled) {
+    const section = this.customSections.get(id);
+    if (section) {
+      section.enabled = enabled;
+    }
+  }
+  getSections() {
+    return Array.from(this.customSections.values());
+  }
+  hasSection(id) {
+    return this.customSections.has(id);
+  }
+  clearCache() {
+    this.envCache = void 0;
+    this.instructionCache = void 0;
+    this.skillRegistryCache = void 0;
+  }
+  async getSkillRegistry(cwd) {
+    if (this.skillRegistryCache && this.skillRegistryCache.cwd === cwd) {
+      return this.skillRegistryCache.registry;
+    }
+    if (!this.config.skills) {
+      const registry2 = emptySkillRegistry();
+      this.skillRegistryCache = { cwd, registry: registry2 };
+      return registry2;
+    }
+    const registry = await createSkillRegistry(cwd, this.config.skills);
+    this.skillRegistryCache = { cwd, registry };
+    return registry;
+  }
+  getModelFamily(model) {
+    return this.config.modelFamily ?? detectModelFamily(model);
+  }
+  getBaseTemplate(model) {
+    const family = this.getModelFamily(model);
+    return this.config.baseTemplate ?? getTemplate(family);
+  }
+  async preview(context, middleware) {
+    return await previewPromptSections({
+      config: this.config,
+      context,
+      customSections: this.customSections.values(),
+      middleware,
+      sources: {
+        getEnvironment: (cwd) => this.getEnvironment(cwd),
+        getInstructions: (cwd) => this.getInstructions(cwd),
+        getSkillRegistry: (cwd) => this.getSkillRegistry(cwd)
+      }
+    });
+  }
+  getEnvironment(cwd) {
+    if (this.envCache && this.envCache.cwd === cwd) {
+      return this.envCache.info;
+    }
+    const info = gatherEnvironment(cwd);
+    this.envCache = { cwd, info };
+    return info;
+  }
+  async getInstructions(cwd) {
+    if (this.instructionCache && this.instructionCache.cwd === cwd) {
+      return this.instructionCache.files;
+    }
+    const patterns = this.config.instructionPatterns ?? DEFAULT_INSTRUCTION_PATTERNS;
+    const maxDepth = this.config.instructionMaxDepth;
+    const maxFileSize = this.config.instructionMaxSize;
+    const localFiles = await discoverInstructions(cwd, patterns, {
+      maxDepth,
+      maxFileSize
+    });
+    const globalFiles = this.config.globalInstructions ? await loadGlobalInstructions(
+      this.config.globalInstructions,
+      maxFileSize
+    ) : [];
+    const allFiles = [...globalFiles, ...localFiles];
+    this.instructionCache = { cwd, files: allFiles };
+    return allFiles;
+  }
+};
+function createPromptBuilder(config) {
+  return new PromptBuilder(config);
+}
+
+export {
+  detectModelFamily,
+  getTemplate,
+  getAvailableFamilies,
+  gatherEnvironment,
+  formatEnvironment,
+  summarizeEnvironment,
+  DEFAULT_INSTRUCTION_PATTERNS,
+  DEFAULT_MAX_FILE_SIZE,
+  DEFAULT_MAX_DEPTH,
+  discoverInstructions,
+  loadGlobalInstructions,
+  formatInstructions,
+  PRIORITY_BASE,
+  PRIORITY_ENVIRONMENT,
+  PRIORITY_INSTRUCTIONS,
+  PRIORITY_CUSTOM,
+  PRIORITY_SKILLS,
+  PRIORITY_OVERRIDE,
+  PromptBuilder,
+  createPromptBuilder
+};