@ulpi/cli 0.1.5 → 0.1.6

package/dist/chunk-WED4LM5N.js

@@ -0,0 +1,322 @@
+import {
+  installKiroSkill
+} from "./chunk-IZPJHSPX.js";
+import {
+  BUNDLED_SKILLS
+} from "./chunk-4ZPOZULQ.js";
+import {
+  getBinaryPath
+} from "./chunk-C7CLUQI6.js";
+
+// ../../packages/agent-installer/dist/index.js
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as fs2 from "fs";
+import * as path2 from "path";
+function buildMcpServers() {
+  const binary = getBinaryPath();
+  return {
+    "ulpi-codemap": {
+      command: binary,
+      args: ["codemap", "serve"],
+      transportType: "stdio"
+    },
+    "ulpi-memory": {
+      command: binary,
+      args: ["memory", "serve"],
+      transportType: "stdio"
+    }
+  };
+}
+function kiroAgentsDir() {
+  return path.join(os.homedir(), ".kiro", "agents");
+}
+function kiroAgentPath(name) {
+  return path.join(kiroAgentsDir(), `${name}.json`);
+}
+function kiroSkillsDir(projectDir) {
+  return path.join(projectDir, ".kiro", "skills");
+}
+function buildHooks() {
+  const binary = getBinaryPath();
+  return {
+    agentSpawn: [{ command: `${binary} session-start` }],
+    preToolUse: [{ matcher: "*", command: `${binary} pre-tool` }],
+    postToolUse: [{ matcher: "*", command: `${binary} post-tool` }],
+    stop: [{ command: `${binary} stop` }]
+  };
+}
+function generateAgentConfig() {
+  return {
+    name: "ulpi-governance",
+    description: "ULPI-governed coding agent. Enforces rules from .ulpi/guards.yml, tracks sessions, captures memory, and provides CodeMap semantic search.",
+    tools: ["read", "write", "shell"],
+    allowedTools: ["read"],
+    hooks: buildHooks(),
+    resources: [
+      "skill://.kiro/skills/*/SKILL.md",
+      "file://.ulpi/guards.yml"
+    ],
+    mcpServers: buildMcpServers()
+  };
+}
+function installKiroHooks(mode) {
+  if (mode === "agent") {
+    const agentConfig = generateAgentConfig();
+    const agentPath = kiroAgentPath("ulpi-governance");
+    const dir2 = path.dirname(agentPath);
+    fs.mkdirSync(dir2, { recursive: true });
+    fs.writeFileSync(agentPath, JSON.stringify(agentConfig, null, 2) + "\n", "utf-8");
+    return { file: agentPath, agent: "ulpi-governance" };
+  }
+  const defaultPath = kiroAgentPath("kiro_default");
+  let config = {};
+  if (fs.existsSync(defaultPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(defaultPath, "utf-8"));
+    } catch {
+    }
+  }
+  config.hooks = buildHooks();
+  config.mcpServers = { ...config.mcpServers ?? {}, ...buildMcpServers() };
+  const dir = path.dirname(defaultPath);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(defaultPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  return { file: defaultPath, agent: "kiro_default" };
+}
+function installKiroSkills(projectDir) {
+  let count = 0;
+  for (const skillInfo of BUNDLED_SKILLS) {
+    const skill = {
+      name: skillInfo.id,
+      path: skillInfo.filename,
+      source: "bundled",
+      description: skillInfo.description
+    };
+    const dirName = `ulpi-${skillInfo.id}`;
+    const skillDir = path.join(kiroSkillsDir(projectDir), dirName);
+    const skillPath = path.join(skillDir, "SKILL.md");
+    if (fs.existsSync(skillPath)) continue;
+    installKiroSkill(skill, projectDir, "repo");
+    count++;
+  }
+  return count;
+}
+function uninstallKiro(projectDir) {
+  let agentRemoved = false;
+  let skillsRemoved = 0;
+  let agentsRemoved = 0;
+  const agentPath = kiroAgentPath("ulpi-governance");
+  if (fs.existsSync(agentPath)) {
+    fs.unlinkSync(agentPath);
+    agentRemoved = true;
+  }
+  const skillsDir = kiroSkillsDir(projectDir);
+  if (fs.existsSync(skillsDir)) {
+    const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && entry.name.startsWith("ulpi-")) {
+        fs.rmSync(path.join(skillsDir, entry.name), { recursive: true, force: true });
+        skillsRemoved++;
+      }
+    }
+  }
+  const claudeAgentsDir = path.join(projectDir, ".claude", "agents");
+  const kiroAgentsBase = path.join(projectDir, ".kiro", "agents");
+  if (fs.existsSync(claudeAgentsDir) && fs.existsSync(kiroAgentsBase)) {
+    const claudeEntries = fs.readdirSync(claudeAgentsDir);
+    for (const file of claudeEntries) {
+      if (!file.endsWith(".md")) continue;
+      const agentName = file.replace(/\.md$/, "");
+      const kiroJson = path.join(kiroAgentsBase, `${agentName}.json`);
+      const kiroPromptDir = path.join(kiroAgentsBase, agentName);
+      if (fs.existsSync(kiroJson)) {
+        fs.unlinkSync(kiroJson);
+        agentsRemoved++;
+      }
+      if (fs.existsSync(kiroPromptDir)) {
+        fs.rmSync(kiroPromptDir, { recursive: true, force: true });
+      }
+    }
+  }
+  return { agentRemoved, skillsRemoved, agentsRemoved };
+}
+function getKiroStatus(projectDir) {
+  const agentPath = kiroAgentPath("ulpi-governance");
+  const agentInstalled = fs.existsSync(agentPath);
+  let skillCount = 0;
+  let convertedSkillCount = 0;
+  const skillsDir = kiroSkillsDir(projectDir);
+  if (fs.existsSync(skillsDir)) {
+    const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      if (e.name.startsWith("ulpi-")) {
+        skillCount++;
+      } else {
+        convertedSkillCount++;
+      }
+    }
+  }
+  let convertedAgentCount = 0;
+  const claudeAgentsDir = path.join(projectDir, ".claude", "agents");
+  const kiroAgentsBase = path.join(projectDir, ".kiro", "agents");
+  if (fs.existsSync(claudeAgentsDir) && fs.existsSync(kiroAgentsBase)) {
+    const claudeEntries = fs.readdirSync(claudeAgentsDir);
+    for (const file of claudeEntries) {
+      if (!file.endsWith(".md")) continue;
+      const agentName = file.replace(/\.md$/, "");
+      if (fs.existsSync(path.join(kiroAgentsBase, `${agentName}.json`))) {
+        convertedAgentCount++;
+      }
+    }
+  }
+  const mcpPath = path.join(projectDir, ".kiro", "settings", "mcp.json");
+  let mcpConfigured = false;
+  if (fs.existsSync(mcpPath)) {
+    try {
+      const mcpConfig = JSON.parse(fs.readFileSync(mcpPath, "utf-8"));
+      const servers = mcpConfig.mcpServers;
+      mcpConfigured = !!(servers?.["ulpi-codemap"] || servers?.["ulpi-memory"]);
+    } catch {
+    }
+  }
+  return { agentInstalled, agentPath, skillCount, convertedSkillCount, convertedAgentCount, mcpConfigured };
+}
+function installCodexMcpServers(projectDir) {
+  const configPath = path2.join(projectDir, ".codex", "config.toml");
+  let content = "";
+  if (fs2.existsSync(configPath)) {
+    content = fs2.readFileSync(configPath, "utf-8");
+  }
+  const servers = buildMcpServers();
+  let added = 0;
+  for (const [name, entry] of Object.entries(servers)) {
+    const actualHeader = `[mcp_servers.${name}]`;
+    if (content.includes(actualHeader)) continue;
+    const argsToml = entry.args.map((a) => `"${a}"`).join(", ");
+    content += `
+${actualHeader}
+command = "${entry.command}"
+args = [${argsToml}]
+`;
+    added++;
+  }
+  if (added > 0) {
+    const dir = path2.dirname(configPath);
+    fs2.mkdirSync(dir, { recursive: true });
+    fs2.writeFileSync(configPath, content, "utf-8");
+  }
+  return added;
+}
+function uninstallCodex(projectDir) {
+  let agentsRemoved = 0;
+  let skillsRemoved = 0;
+  let mcpRemoved = false;
+  const claudeAgentsDir = path2.join(projectDir, ".claude", "agents");
+  const codexAgentsBase = path2.join(projectDir, ".codex", "agents");
+  if (fs2.existsSync(claudeAgentsDir) && fs2.existsSync(codexAgentsBase)) {
+    const claudeEntries = fs2.readdirSync(claudeAgentsDir);
+    for (const file of claudeEntries) {
+      if (!file.endsWith(".md")) continue;
+      const agentName = file.replace(/\.md$/, "");
+      const codexToml = path2.join(codexAgentsBase, `${agentName}.toml`);
+      const codexInstructionsDir = path2.join(codexAgentsBase, agentName);
+      if (fs2.existsSync(codexToml)) {
+        fs2.unlinkSync(codexToml);
+        agentsRemoved++;
+      }
+      if (fs2.existsSync(codexInstructionsDir)) {
+        fs2.rmSync(codexInstructionsDir, { recursive: true, force: true });
+      }
+    }
+  }
+  const claudeSkillsDir = path2.join(projectDir, ".claude", "skills");
+  const codexSkillsDir = path2.join(projectDir, ".codex", "skills");
+  if (fs2.existsSync(claudeSkillsDir) && fs2.existsSync(codexSkillsDir)) {
+    const claudeEntries = fs2.readdirSync(claudeSkillsDir, { withFileTypes: true });
+    for (const entry of claudeEntries) {
+      if (!entry.isDirectory()) continue;
+      const codexSkillDir = path2.join(codexSkillsDir, entry.name);
+      if (fs2.existsSync(codexSkillDir)) {
+        fs2.rmSync(codexSkillDir, { recursive: true, force: true });
+        skillsRemoved++;
+      }
+    }
+  }
+  const configPath = path2.join(projectDir, ".codex", "config.toml");
+  if (fs2.existsSync(configPath)) {
+    let content = fs2.readFileSync(configPath, "utf-8");
+    const originalLen = content.length;
+    for (const name of ["ulpi-codemap", "ulpi-memory"]) {
+      const sectionRegex = new RegExp(
+        `\\n?\\[mcp_servers\\.${name.replace(/-/g, "\\-")}\\]\\n(?:[^\\[]*?)(?=\\n\\[|$)`,
+        "s"
+      );
+      content = content.replace(sectionRegex, "");
+    }
+    if (fs2.existsSync(claudeAgentsDir)) {
+      const claudeEntries = fs2.readdirSync(claudeAgentsDir);
+      for (const file of claudeEntries) {
+        if (!file.endsWith(".md")) continue;
+        const agentName = file.replace(/\.md$/, "");
+        const sectionRegex = new RegExp(
+          `\\n?\\[agents\\.${agentName}\\]\\n(?:[^\\[]*?)(?=\\n\\[|$)`,
+          "s"
+        );
+        content = content.replace(sectionRegex, "");
+      }
+    }
+    if (content.length !== originalLen) {
+      mcpRemoved = true;
+      fs2.writeFileSync(configPath, content.trim() + "\n", "utf-8");
+    }
+  }
+  return { agentsRemoved, skillsRemoved, mcpRemoved };
+}
+function getCodexStatus(projectDir) {
+  let convertedAgentCount = 0;
+  let convertedSkillCount = 0;
+  const claudeAgentsDir = path2.join(projectDir, ".claude", "agents");
+  const codexAgentsBase = path2.join(projectDir, ".codex", "agents");
+  if (fs2.existsSync(claudeAgentsDir) && fs2.existsSync(codexAgentsBase)) {
+    const claudeEntries = fs2.readdirSync(claudeAgentsDir);
+    for (const file of claudeEntries) {
+      if (!file.endsWith(".md")) continue;
+      const agentName = file.replace(/\.md$/, "");
+      if (fs2.existsSync(path2.join(codexAgentsBase, `${agentName}.toml`))) {
+        convertedAgentCount++;
+      }
+    }
+  }
+  const claudeSkillsDir = path2.join(projectDir, ".claude", "skills");
+  const codexSkillsDir = path2.join(projectDir, ".codex", "skills");
+  if (fs2.existsSync(claudeSkillsDir) && fs2.existsSync(codexSkillsDir)) {
+    const claudeEntries = fs2.readdirSync(claudeSkillsDir, { withFileTypes: true });
+    for (const entry of claudeEntries) {
+      if (!entry.isDirectory()) continue;
+      if (fs2.existsSync(path2.join(codexSkillsDir, entry.name, "SKILL.md"))) {
+        convertedSkillCount++;
+      }
+    }
+  }
+  const configPath = path2.join(projectDir, ".codex", "config.toml");
+  let mcpConfigured = false;
+  if (fs2.existsSync(configPath)) {
+    const content = fs2.readFileSync(configPath, "utf-8");
+    mcpConfigured = content.includes("[mcp_servers.ulpi-codemap]") || content.includes("[mcp_servers.ulpi-memory]");
+  }
+  return { convertedAgentCount, convertedSkillCount, mcpConfigured };
+}
+
+export {
+  buildMcpServers,
+  installKiroHooks,
+  installKiroSkills,
+  uninstallKiro,
+  getKiroStatus,
+  installCodexMcpServers,
+  uninstallCodex,
+  getCodexStatus
+};

package/dist/{chunk-74WVVWJ4.js → chunk-YOKL7RB5.js}

@@ -136,9 +136,9 @@ var PlanStatusSchema = external_exports.enum([
   "executing",
   "completed"
 ]);
-var CodemapEmbeddingProviderSchema = external_exports.enum(["openai", "ollama", "ulpi"]);
-var CodemapEmbeddingConfigSchema = external_exports.object({
-  provider: CodemapEmbeddingProviderSchema.default("ulpi"),
+var EmbeddingProviderSchema = external_exports.enum(["openai", "ollama", "ulpi"]);
+var EmbeddingConfigSchema = external_exports.object({
+  provider: EmbeddingProviderSchema.default("ulpi"),
   model: external_exports.string().max(100).default("code"),
   dimensions: external_exports.number().int().positive().max(4096).default(1024),
   baseUrl: external_exports.string().url().max(200).optional()
@@ -175,13 +175,15 @@ var CodemapHybridConfigSchema = external_exports.object({
   weights: CodemapHybridWeightsSchema.default({})
 });
 var CodemapConfigSchema = external_exports.object({
-  embedding: CodemapEmbeddingConfigSchema.default({}),
+  embedding: EmbeddingConfigSchema.default({}),
   chunking: CodemapChunkingConfigSchema.default({}),
   batch: CodemapBatchConfigSchema.default({}),
   hybrid: CodemapHybridConfigSchema.default({}),
   deny: external_exports.array(external_exports.string().max(500)).max(200).default(["**/.env*", "**/secrets/**", "**/certs/**"]),
   maxFileSize: external_exports.number().int().positive().default(1048576),
   // 1MB
+  searchTimeoutMs: external_exports.number().int().positive().default(15e3),
+  // Search embed timeout
   autoExport: external_exports.boolean().default(true),
   // Export to shadow branch on push / session-end
   autoImport: external_exports.boolean().default(true)
@@ -256,12 +258,6 @@ var MemoryEntrySchema = external_exports.object({
   lastAccessedAt: external_exports.string().optional(),
   supersededBy: external_exports.string().max(64).optional()
 });
-var MemoryEmbeddingConfigSchema = external_exports.object({
-  provider: external_exports.enum(["openai", "ollama", "ulpi"]).default("ulpi"),
-  model: external_exports.string().max(100).default("code"),
-  dimensions: external_exports.number().int().positive().max(4096).default(1024),
-  baseUrl: external_exports.string().url().max(200).optional()
-});
 var MemoryClassifierConfigSchema = external_exports.object({
   enabled: external_exports.boolean().default(true),
   model: external_exports.string().max(100).default("claude-sonnet-4-20250514"),
@@ -294,7 +290,7 @@ var MemoryConfigSchema = external_exports.object({
   captureMode: CaptureModeSchema.default("continuous"),
   surfaceOnStart: external_exports.boolean().default(true),
   surfaceLimit: external_exports.number().int().positive().max(20).default(5),
-  embedding: MemoryEmbeddingConfigSchema.default({}),
+  embedding: EmbeddingConfigSchema.default({ model: "memory" }),
   classifier: MemoryClassifierConfigSchema.default({}),
   retention: MemoryRetentionConfigSchema.default({}),
   ranking: MemoryRankingConfigSchema.default({}),
@@ -328,6 +324,159 @@ var DepgraphConfigSchema = external_exports.object({
   excludeUnranked: external_exports.boolean().default(false),
   excludeUnrankedThreshold: external_exports.number().nonnegative().default(1e-4)
 });
+var TrackerTaskStatusSchema = external_exports.enum([
+  "open",
+  "in_progress",
+  "done",
+  "failed",
+  "skipped"
+]);
+var TaskPrioritySchema = external_exports.union([
+  external_exports.literal(0),
+  external_exports.literal(1),
+  external_exports.literal(2),
+  external_exports.literal(3),
+  external_exports.literal(4)
+]);
+var TrackerTaskSchema = external_exports.object({
+  id: external_exports.string(),
+  title: external_exports.string(),
+  status: TrackerTaskStatusSchema,
+  priority: TaskPrioritySchema,
+  description: external_exports.string().optional(),
+  labels: external_exports.array(external_exports.string()).optional(),
+  type: external_exports.string().optional(),
+  parentId: external_exports.string().optional(),
+  dependsOn: external_exports.array(external_exports.string()).optional(),
+  blocks: external_exports.array(external_exports.string()).optional(),
+  assignee: external_exports.string().optional(),
+  createdAt: external_exports.string().optional(),
+  updatedAt: external_exports.string().optional(),
+  metadata: external_exports.record(external_exports.unknown()).optional()
+});
+var TaskFilterSchema = external_exports.object({
+  status: external_exports.union([TrackerTaskStatusSchema, external_exports.array(TrackerTaskStatusSchema)]).optional(),
+  priority: external_exports.union([TaskPrioritySchema, external_exports.array(TaskPrioritySchema)]).optional(),
+  labels: external_exports.array(external_exports.string()).optional(),
+  assignee: external_exports.string().optional(),
+  type: external_exports.union([external_exports.string(), external_exports.array(external_exports.string())]).optional(),
+  parentId: external_exports.string().optional(),
+  ready: external_exports.boolean().optional(),
+  limit: external_exports.number().int().positive().optional(),
+  offset: external_exports.number().int().nonnegative().optional(),
+  excludeIds: external_exports.array(external_exports.string()).optional()
+});
+var TaskCompletionResultSchema = external_exports.object({
+  taskId: external_exports.string(),
+  status: TrackerTaskStatusSchema,
+  summary: external_exports.string(),
+  filesChanged: external_exports.array(external_exports.string()).optional(),
+  commitSha: external_exports.string().optional()
+});
+var AgentPluginMetaSchema = external_exports.object({
+  name: external_exports.string(),
+  version: external_exports.string(),
+  description: external_exports.string(),
+  cliCommand: external_exports.string(),
+  supportsHooks: external_exports.boolean(),
+  supportsSkills: external_exports.boolean(),
+  supportsStreaming: external_exports.boolean(),
+  supportsSubagentTracing: external_exports.boolean()
+});
+var ExecuteOptionsSchema = external_exports.object({
+  prompt: external_exports.string(),
+  workingDir: external_exports.string(),
+  timeout: external_exports.number().positive().optional(),
+  env: external_exports.record(external_exports.string()).optional(),
+  sandboxConfig: external_exports.record(external_exports.unknown()).optional()
+});
+var ExecuteResultSchema = external_exports.object({
+  exitCode: external_exports.number(),
+  stdout: external_exports.string(),
+  stderr: external_exports.string(),
+  duration: external_exports.number(),
+  tokenUsage: external_exports.object({
+    input: external_exports.number().optional(),
+    output: external_exports.number().optional()
+  }).optional()
+});
+var TrackerPluginMetaSchema = external_exports.object({
+  id: external_exports.string(),
+  name: external_exports.string(),
+  description: external_exports.string(),
+  version: external_exports.string(),
+  supportsBidirectionalSync: external_exports.boolean(),
+  supportsHierarchy: external_exports.boolean(),
+  supportsDependencies: external_exports.boolean()
+});
+var SyncResultSchema = external_exports.object({
+  success: external_exports.boolean(),
+  message: external_exports.string(),
+  added: external_exports.number().optional(),
+  updated: external_exports.number().optional(),
+  removed: external_exports.number().optional(),
+  error: external_exports.string().optional(),
+  syncedAt: external_exports.string()
+});
+var McpConfigFieldSchema = external_exports.object({
+  type: external_exports.enum(["string", "number", "boolean"]).default("string"),
+  format: external_exports.enum(["env-ref", "plain"]).optional(),
+  required: external_exports.boolean().default(false),
+  sensitive: external_exports.boolean().default(false),
+  description: external_exports.string().optional(),
+  default: external_exports.union([external_exports.string(), external_exports.number(), external_exports.boolean()]).optional()
+});
+var McpTransportSchema = external_exports.enum(["stdio", "sse", "http"]).default("stdio");
+var McpCategorySchema = external_exports.enum([
+  "database",
+  "api",
+  "devtools",
+  "comms",
+  "analytics",
+  "cloud",
+  "ai",
+  "search",
+  "monitoring",
+  "project-management",
+  "design",
+  "custom"
+]).default("custom");
+var McpSourceSchema = external_exports.enum(["catalog", "manual"]).default("manual");
+var McpDetectSignalsSchema = external_exports.object({
+  dependencies: external_exports.array(external_exports.string()).default([]),
+  env_vars: external_exports.array(external_exports.string()).default([]),
+  docker_services: external_exports.array(external_exports.string()).default([]),
+  config_files: external_exports.array(external_exports.string()).default([])
+}).partial();
+var McpDefinitionSchema = external_exports.object({
+  name: external_exports.string().min(1).max(128),
+  display_name: external_exports.string().max(256).optional(),
+  description: external_exports.string().max(1024).optional(),
+  command: external_exports.string().min(1).max(256),
+  args: external_exports.array(external_exports.string()).default([]),
+  transport: McpTransportSchema,
+  category: McpCategorySchema,
+  config_schema: external_exports.record(external_exports.string(), McpConfigFieldSchema).optional(),
+  tags: external_exports.array(external_exports.string()).default([]),
+  source: McpSourceSchema,
+  added_at: external_exports.string().optional()
+});
+var McpLibrarySchema = external_exports.object({
+  mcps: external_exports.record(external_exports.string(), McpDefinitionSchema).default({})
+});
+var McpActivationSchema = external_exports.object({
+  enabled: external_exports.boolean().default(true),
+  config: external_exports.record(external_exports.string(), external_exports.union([external_exports.string(), external_exports.number(), external_exports.boolean()])).default({})
+});
+var McpRepoConfigSchema = external_exports.object({
+  mcps: external_exports.record(external_exports.string(), McpActivationSchema).default({})
+});
+var McpCatalogEntrySchema = McpDefinitionSchema.extend({
+  detect_signals: McpDetectSignalsSchema.optional()
+});
+var McpCatalogSchema = external_exports.object({
+  catalog: external_exports.array(McpCatalogEntrySchema).default([])
+});
 
 export {
   BlockTypeSchema,
@@ -349,8 +498,8 @@ export {
   ReviewDecisionSchema,
   RepoInfoSchema,
   PlanStatusSchema,
-  CodemapEmbeddingProviderSchema,
-  CodemapEmbeddingConfigSchema,
+  EmbeddingProviderSchema,
+  EmbeddingConfigSchema,
   CodemapChunkingStrategySchema,
   CodemapChunkingConfigSchema,
   CodemapBatchConfigSchema,
@@ -363,7 +512,6 @@ export {
   CaptureModeSchema,
   MemorySourceSchema,
   MemoryEntrySchema,
-  MemoryEmbeddingConfigSchema,
   MemoryClassifierConfigSchema,
   MemoryRetentionConfigSchema,
   MemoryRankingConfigSchema,
@@ -371,5 +519,26 @@ export {
   ClassificationResultSchema,
   DepgraphPersonalizationConfigSchema,
   DepgraphPagerankConfigSchema,
-  DepgraphConfigSchema
+  DepgraphConfigSchema,
+  TrackerTaskStatusSchema,
+  TaskPrioritySchema,
+  TrackerTaskSchema,
+  TaskFilterSchema,
+  TaskCompletionResultSchema,
+  AgentPluginMetaSchema,
+  ExecuteOptionsSchema,
+  ExecuteResultSchema,
+  TrackerPluginMetaSchema,
+  SyncResultSchema,
+  McpConfigFieldSchema,
+  McpTransportSchema,
+  McpCategorySchema,
+  McpSourceSchema,
+  McpDetectSignalsSchema,
+  McpDefinitionSchema,
+  McpLibrarySchema,
+  McpActivationSchema,
+  McpRepoConfigSchema,
+  McpCatalogEntrySchema,
+  McpCatalogSchema
 };