@dexto/agent-management 1.6.1 → 1.6.2

package/dist/tool-factories/creator-tools/factory.cjs

@@ -0,0 +1,434 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var factory_exports = {};
+__export(factory_exports, {
+  creatorToolsFactory: () => creatorToolsFactory
+});
+module.exports = __toCommonJS(factory_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_yaml = require("yaml");
+var import_core = require("@dexto/core");
+var import_discover_skills = require("../../plugins/discover-skills.js");
+var import_schemas = require("./schemas.js");
+var import_path = require("../../utils/path.js");
+var import_zod = require("zod");
+const SkillCreateInputSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1).describe("Skill id (kebab-case)."),
+  description: import_zod.z.string().min(1).describe("Short description of what the skill does."),
+  content: import_zod.z.string().min(1).describe("Skill body (markdown) without frontmatter."),
+  allowedTools: import_zod.z.array(import_zod.z.string().min(1)).optional().describe("Optional allowed-tools list for the skill frontmatter."),
+  toolkits: import_zod.z.array(import_zod.z.string().min(1)).optional().describe("Optional toolkits list for the skill frontmatter."),
+  scope: import_zod.z.enum(["global", "workspace"]).optional(),
+  overwrite: import_zod.z.boolean().optional()
+}).strict();
+const SkillUpdateInputSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1),
+  content: import_zod.z.string().min(1).describe("New SKILL.md body (markdown) without frontmatter."),
+  description: import_zod.z.string().min(1).optional(),
+  allowedTools: import_zod.z.array(import_zod.z.string().min(1)).optional().describe("Optional allowed-tools list for the skill frontmatter."),
+  toolkits: import_zod.z.array(import_zod.z.string().min(1)).optional().describe("Optional toolkits list for the skill frontmatter."),
+  scope: import_zod.z.enum(["global", "workspace"]).optional()
+}).strict();
+const SkillListInputSchema = import_zod.z.object({
+  projectPath: import_zod.z.string().optional(),
+  query: import_zod.z.string().optional().describe("Optional search term to filter skills by name or path")
+}).strict();
+const SkillSearchInputSchema = import_zod.z.object({
+  query: import_zod.z.string().optional().describe("Optional search term to filter skills by name or description"),
+  limit: import_zod.z.number().int().min(1).max(200).optional().describe(
+    "Maximum number of skills to return. If omitted, all matches are returned for queries; otherwise defaults to 50."
+  )
+}).strict();
+const ToolCatalogInputSchema = import_zod.z.object({
+  query: import_zod.z.string().optional().describe("Optional search term to filter tools by id or description"),
+  limit: import_zod.z.number().int().min(1).max(500).optional().describe("Maximum number of tools to return (defaults to all)."),
+  includeDescriptions: import_zod.z.boolean().optional().describe("Include tool descriptions (defaults to true).")
+}).strict();
+function normalizeSkillQuery(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+function matchesSkillQuery(value, query) {
+  if (!value) return false;
+  const normalizedQuery = normalizeSkillQuery(query);
+  if (!normalizedQuery) return false;
+  return normalizeSkillQuery(value).includes(normalizedQuery);
+}
+function resolvePromptSkillName(info, id) {
+  return info.displayName || info.name || id;
+}
+function resolveWorkspaceBasePath(context) {
+  const workspacePath = context.workspace?.path;
+  const fallbackWorkingDir = context.services ? context.services.filesystemService?.getConfig().workingDirectory : void 0;
+  return workspacePath || fallbackWorkingDir || process.cwd();
+}
+function resolveWorkspaceSkillDirs(context) {
+  const base = resolveWorkspaceBasePath(context);
+  return {
+    primary: import_node_path.default.join(base, ".agents", "skills"),
+    legacy: import_node_path.default.join(base, ".dexto", "skills")
+  };
+}
+function resolveSkillBaseDirectory(scope, context) {
+  if (scope === "global") {
+    return { baseDir: (0, import_path.getDextoGlobalPath)("skills"), scope: "global" };
+  }
+  return { baseDir: resolveWorkspaceSkillDirs(context).primary, scope: "workspace" };
+}
+function resolveSkillDirectory(input, context) {
+  return resolveSkillBaseDirectory(input.scope, context);
+}
+async function pathExists(filePath) {
+  return await import_node_fs.promises.stat(filePath).then(() => true).catch(() => false);
+}
+async function resolveSkillUpdateDirectory(input, context) {
+  if (input.scope === "global") {
+    return resolveSkillBaseDirectory("global", context);
+  }
+  const { primary, legacy } = resolveWorkspaceSkillDirs(context);
+  const skillId = input.id.trim();
+  const primaryFile = import_node_path.default.join(primary, skillId, "SKILL.md");
+  if (await pathExists(primaryFile)) {
+    return { baseDir: primary, scope: "workspace" };
+  }
+  const legacyFile = import_node_path.default.join(legacy, skillId, "SKILL.md");
+  if (await pathExists(legacyFile)) {
+    return { baseDir: legacy, scope: "workspace" };
+  }
+  return { baseDir: primary, scope: "workspace" };
+}
+function ensurePathWithinBase(baseDir, targetDir, toolId) {
+  const resolvedBase = import_node_path.default.resolve(baseDir);
+  const resolvedTarget = import_node_path.default.resolve(targetDir);
+  const rel = import_node_path.default.relative(resolvedBase, resolvedTarget);
+  if (rel.startsWith("..") || import_node_path.default.isAbsolute(rel)) {
+    throw import_core.ToolError.validationFailed(toolId, "invalid skill path");
+  }
+}
+function formatFrontmatterLine(key, value) {
+  if (typeof value === "string") {
+    return `${key}: ${JSON.stringify(value)}`;
+  }
+  return `${key}: ${value}`;
+}
+function titleizeSkillId(id) {
+  return id.split("-").filter(Boolean).map((segment) => segment[0]?.toUpperCase() + segment.slice(1)).join(" ");
+}
+function resolveSkillCreateInput(input) {
+  const id = input.id.trim();
+  const description = input.description.trim();
+  const content = input.content.trim();
+  return {
+    ...input,
+    id,
+    description,
+    content
+  };
+}
+function formatFrontmatterList(key, values) {
+  const normalized = values.map((value) => JSON.stringify(value.trim()));
+  return `${key}: [${normalized.join(", ")}]`;
+}
+function buildSkillMarkdownFromParts(options) {
+  const id = options.id.trim();
+  const title = titleizeSkillId(id) || id;
+  const lines = ["---"];
+  lines.push(formatFrontmatterLine("name", id));
+  lines.push(formatFrontmatterLine("description", options.description.trim()));
+  if (options.toolkits && options.toolkits.length > 0) {
+    lines.push(formatFrontmatterList("toolkits", options.toolkits));
+  }
+  if (options.allowedTools && options.allowedTools.length > 0) {
+    lines.push(formatFrontmatterList("allowed-tools", options.allowedTools));
+  }
+  lines.push("---", "", `# ${title}`, "", options.content.trim());
+  return lines.join("\n").replace(/\n{3,}/g, "\n\n");
+}
+function buildSkillMarkdown(input) {
+  return buildSkillMarkdownFromParts({
+    id: input.id,
+    description: input.description,
+    content: input.content,
+    allowedTools: input.allowedTools,
+    toolkits: input.toolkits
+  });
+}
+async function readSkillFrontmatter(skillFile) {
+  try {
+    const raw = await import_node_fs.promises.readFile(skillFile, "utf-8");
+    const match = raw.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+    if (!match) return {};
+    const frontmatter = (0, import_yaml.parse)(match[1] ?? "");
+    if (!frontmatter || typeof frontmatter !== "object") return {};
+    const name = typeof frontmatter.name === "string" ? frontmatter.name.trim() : void 0;
+    const description = typeof frontmatter.description === "string" ? frontmatter.description.trim() : void 0;
+    const allowedToolsRaw = frontmatter["allowed-tools"];
+    const toolkitsRaw = frontmatter.toolkits;
+    const allowedTools = Array.isArray(allowedToolsRaw) ? allowedToolsRaw.filter((item) => typeof item === "string").map((item) => item.trim()).filter((item) => item.length > 0) : void 0;
+    const toolkits = Array.isArray(toolkitsRaw) ? toolkitsRaw.filter((item) => typeof item === "string").map((item) => item.trim()).filter((item) => item.length > 0) : void 0;
+    const result = {};
+    if (name) result.name = name;
+    if (description) result.description = description;
+    if (allowedTools && allowedTools.length > 0) result.allowedTools = allowedTools;
+    if (toolkits && toolkits.length > 0) result.toolkits = toolkits;
+    return result;
+  } catch {
+    return {};
+  }
+}
+async function refreshAgentPrompts(context, skillFile) {
+  const agent = context.agent;
+  if (!agent) return false;
+  const effective = agent.getEffectiveConfig();
+  const existingPrompts = Array.isArray(effective.prompts) ? [...effective.prompts] : [];
+  const alreadyPresent = existingPrompts.some((prompt) => {
+    if (!prompt || typeof prompt !== "object") return false;
+    const record = prompt;
+    return record.type === "file" && record.file === skillFile;
+  });
+  const nextPrompts = alreadyPresent ? existingPrompts : [...existingPrompts, { type: "file", file: skillFile }];
+  await agent.refreshPrompts(nextPrompts);
+  return true;
+}
+const creatorToolsFactory = {
+  configSchema: import_schemas.CreatorToolsConfigSchema,
+  metadata: {
+    displayName: "Creator Tools",
+    description: "Create and manage standalone skills",
+    category: "agents"
+  },
+  create: (config) => {
+    const enabledTools = config.enabledTools ?? import_schemas.CREATOR_TOOL_NAMES;
+    const skillCreateTool = (0, import_core.defineTool)({
+      id: "skill_create",
+      description: "Create a standalone SKILL.md file and register it with the running agent. Provide id, description, content, and optional toolkits/allowedTools.",
+      inputSchema: SkillCreateInputSchema,
+      execute: async (input, context) => {
+        const resolvedInput = resolveSkillCreateInput(input);
+        const skillId = resolvedInput.id.trim();
+        (0, import_core.assertValidPromptName)(skillId, {
+          context: "skill_create",
+          hint: "Use kebab-case skill ids (e.g., release-notes)"
+        });
+        const { baseDir, scope } = resolveSkillDirectory(resolvedInput, context);
+        const skillDir = import_node_path.default.join(baseDir, skillId);
+        ensurePathWithinBase(baseDir, skillDir, "skill_create");
+        const skillFile = import_node_path.default.join(skillDir, "SKILL.md");
+        const exists = await pathExists(skillFile);
+        if (exists && !resolvedInput.overwrite) {
+          throw import_core.ToolError.validationFailed(
+            "skill_create",
+            `Skill already exists at ${skillFile}`
+          );
+        }
+        const markdown = buildSkillMarkdown(resolvedInput);
+        await import_node_fs.promises.mkdir(skillDir, { recursive: true });
+        await import_node_fs.promises.writeFile(skillFile, markdown, "utf-8");
+        const refreshed = await refreshAgentPrompts(context, skillFile);
+        const displayName = titleizeSkillId(skillId) || skillId;
+        return {
+          created: true,
+          id: skillId,
+          name: displayName,
+          description: resolvedInput.description.trim(),
+          scope,
+          path: skillFile,
+          promptsRefreshed: refreshed
+        };
+      }
+    });
+    const skillUpdateTool = (0, import_core.defineTool)({
+      id: "skill_update",
+      description: "Update an existing standalone SKILL.md file.",
+      inputSchema: SkillUpdateInputSchema,
+      execute: async (input, context) => {
+        const skillId = input.id.trim();
+        (0, import_core.assertValidPromptName)(skillId, {
+          context: "skill_update",
+          hint: "Use kebab-case skill ids (e.g., release-notes)"
+        });
+        const { baseDir, scope } = await resolveSkillUpdateDirectory(input, context);
+        const skillDir = import_node_path.default.join(baseDir, skillId);
+        ensurePathWithinBase(baseDir, skillDir, "skill_update");
+        const skillFile = import_node_path.default.join(skillDir, "SKILL.md");
+        const exists = await pathExists(skillFile);
+        if (!exists) {
+          throw import_core.ToolError.validationFailed(
+            "skill_update",
+            `Skill not found at ${skillFile}`
+          );
+        }
+        const existing = await readSkillFrontmatter(skillFile);
+        const description = input.description?.trim() || existing.description;
+        if (!description) {
+          throw import_core.ToolError.validationFailed(
+            "skill_update",
+            "description is required when the existing skill is missing one"
+          );
+        }
+        const allowedTools = input.allowedTools !== void 0 ? input.allowedTools : existing.allowedTools;
+        const toolkits = input.toolkits !== void 0 ? input.toolkits : existing.toolkits;
+        const markdown = buildSkillMarkdownFromParts({
+          id: skillId,
+          description,
+          content: input.content.trim(),
+          allowedTools,
+          toolkits
+        });
+        await import_node_fs.promises.writeFile(skillFile, markdown, "utf-8");
+        const refreshed = await refreshAgentPrompts(context, skillFile);
+        return {
+          updated: true,
+          id: skillId,
+          description,
+          scope,
+          path: skillFile,
+          promptsRefreshed: refreshed
+        };
+      }
+    });
+    const skillSearchTool = (0, import_core.defineTool)({
+      id: "skill_search",
+      description: "Search loaded skills (supports query).",
+      inputSchema: SkillSearchInputSchema,
+      execute: async (input, context) => {
+        const query = input.query?.trim() ?? "";
+        const normalizedQuery = normalizeSkillQuery(query);
+        const hasQuery = normalizedQuery.length > 0;
+        const limit = input.limit ?? (hasQuery ? void 0 : 50);
+        const promptManager = context.services?.prompts;
+        if (!promptManager) {
+          throw import_core.ToolError.configInvalid(
+            "skill_search requires ToolExecutionContext.services.prompts"
+          );
+        }
+        const loaded = await promptManager.list();
+        let results = Object.entries(loaded).map(([id, info]) => ({
+          id,
+          name: resolvePromptSkillName(info, id),
+          ...info.displayName ? { displayName: info.displayName } : {},
+          ...info.commandName ? { commandName: info.commandName } : {},
+          ...info.description ? { description: info.description } : {},
+          ...info.context ? { context: info.context } : {},
+          ...info.agent ? { agent: info.agent } : {}
+        }));
+        if (hasQuery && normalizedQuery) {
+          results = results.filter((entry) => {
+            if (matchesSkillQuery(entry.id, normalizedQuery)) return true;
+            if (matchesSkillQuery(entry.name, normalizedQuery)) return true;
+            if (matchesSkillQuery(entry.displayName, normalizedQuery)) return true;
+            if (matchesSkillQuery(entry.commandName, normalizedQuery)) return true;
+            if (matchesSkillQuery(entry.description, normalizedQuery)) return true;
+            return false;
+          });
+        }
+        results.sort((a, b) => a.name.localeCompare(b.name));
+        const limited = typeof limit === "number" ? results.slice(0, limit) : results;
+        return {
+          query: input.query?.trim(),
+          count: limited.length,
+          total: results.length,
+          skills: limited,
+          _hint: limited.length > 0 ? "Use invoke_skill with the skill id or commandName for loaded skills." : "No skills matched the query."
+        };
+      }
+    });
+    const skillListTool = (0, import_core.defineTool)({
+      id: "skill_list",
+      description: "List discovered standalone skills and their search paths. Supports optional query filtering.",
+      inputSchema: SkillListInputSchema,
+      execute: async (input) => {
+        const query = input.query?.trim().toLowerCase();
+        const skills = (0, import_discover_skills.discoverStandaloneSkills)(input.projectPath);
+        const filtered = query ? skills.filter((skill) => {
+          if (skill.name.toLowerCase().includes(query)) return true;
+          if (skill.path.toLowerCase().includes(query)) return true;
+          if (skill.skillFile.toLowerCase().includes(query)) return true;
+          return false;
+        }) : skills;
+        return {
+          searchPaths: (0, import_discover_skills.getSkillSearchPaths)(),
+          skills: filtered
+        };
+      }
+    });
+    const toolCatalogTool = (0, import_core.defineTool)({
+      id: "tool_catalog",
+      description: "List available tools and configured toolkits for the current agent (from the loaded image/config).",
+      inputSchema: ToolCatalogInputSchema,
+      execute: async (input, context) => {
+        const agent = context.agent;
+        if (!agent) {
+          throw import_core.ToolError.configInvalid(
+            "tool_catalog requires ToolExecutionContext.agent"
+          );
+        }
+        const toolSet = await agent.getAllTools();
+        let tools = Object.entries(toolSet).map(([id, tool]) => ({
+          id,
+          description: tool.description || "No description provided",
+          source: id.startsWith("mcp--") ? "mcp" : "local"
+        }));
+        const query = input.query?.trim().toLowerCase();
+        if (query) {
+          tools = tools.filter((tool) => {
+            if (tool.id.toLowerCase().includes(query)) return true;
+            if ((tool.description ?? "").toLowerCase().includes(query)) return true;
+            return false;
+          });
+        }
+        tools.sort((a, b) => a.id.localeCompare(b.id));
+        const includeDescriptions = input.includeDescriptions !== false;
+        if (!includeDescriptions) {
+          tools = tools.map((tool) => ({ id: tool.id, source: tool.source }));
+        }
+        const limited = typeof input.limit === "number" ? tools.slice(0, input.limit) : tools;
+        return {
+          query: input.query?.trim(),
+          count: limited.length,
+          total: tools.length,
+          tools: limited,
+          _hint: limited.length > 0 ? "Use tool ids in allowed-tools. Use toolkits from the agent config or image defaults." : "No tools matched the query."
+        };
+      }
+    });
+    const toolCreators = {
+      skill_create: () => skillCreateTool,
+      skill_update: () => skillUpdateTool,
+      skill_search: () => skillSearchTool,
+      skill_list: () => skillListTool,
+      tool_catalog: () => toolCatalogTool
+    };
+    return enabledTools.map((toolName) => toolCreators[toolName]());
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  creatorToolsFactory
+});

package/dist/tool-factories/creator-tools/factory.d.ts

@@ -0,0 +1,4 @@
+import type { ToolFactory } from '@dexto/agent-config';
+import { type CreatorToolsConfig } from './schemas.js';
+export declare const creatorToolsFactory: ToolFactory<CreatorToolsConfig>;
+//# sourceMappingURL=factory.d.ts.map

package/dist/tool-factories/creator-tools/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/tool-factories/creator-tools/factory.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAWvD,OAAO,EAIH,KAAK,kBAAkB,EAC1B,MAAM,cAAc,CAAC;AAkWtB,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,kBAAkB,CA6P/D,CAAC"}