@fro.bot/systematic 2.14.1 → 2.14.2

package/dist/index.js

@@ -774,6 +774,28 @@ async function getAvailableModels(client, options = {}) {
 }
 
 // src/lib/config-handler.ts
+function isSystematicAgentConfig(agent) {
+  const description = agent?.description;
+  return typeof description === "string" && /\(.* - Systematic\)$/.test(description);
+}
+function isSystematicCommandConfig(command) {
+  const description = command?.description;
+  return typeof description === "string" && (description.startsWith("(Systematic) ") || description.startsWith("(Systematic - Skill) "));
+}
+function mergeSystematicEntries(existing, emitted, shouldDropExisting) {
+  const merged = { ...existing ?? {} };
+  for (const [key, value] of Object.entries(existing ?? {})) {
+    if (shouldDropExisting(key, value)) {
+      delete merged[key];
+    }
+  }
+  for (const [key, value] of Object.entries(emitted)) {
+    if (Object.hasOwn(merged, key))
+      continue;
+    merged[key] = value;
+  }
+  return merged;
+}
 function toTitleCase(name) {
   return name.split("-").map((segment) => segment.length > 0 ? segment.charAt(0).toUpperCase() + segment.slice(1) : segment).join("-");
 }
@@ -912,30 +934,37 @@ function applyAgentOverlays(config, agentInfo, overlays, availabilitySet) {
     addPermissionRules(permissionRules, config.permission);
   }
   result.temperature = inferBuiltInTemperature(agentInfo.name, result.description);
-  if (agentInfo.category && availabilitySet !== undefined) {
-    const resolved = resolveSourceModel(agentInfo.category, availabilitySet);
-    result.model = `${resolved.provider}/${resolved.model}`;
-    if (resolved.variant !== undefined) {
-      result.variant = resolved.variant;
-    } else {
-      delete result.variant;
-    }
-  }
-  if (categoryOverlay) {
-    applyOverlayObjectWithVariantClearing(result, categoryOverlay.value, permissionRules);
-  }
-  if (exactOverlay) {
-    applyOverlayObjectWithVariantClearing(result, exactOverlay.value, permissionRules);
+  applySourceModelDefault(result, agentInfo, availabilitySet);
+  applyAgentOverlay(result, categoryOverlay?.value, permissionRules);
+  applyAgentOverlay(result, exactOverlay?.value, permissionRules);
+  applyPermissionOverlay(result, permissionRules, hasPermissionOverlay);
+  return result;
+}
+function applySourceModelDefault(target, agentInfo, availabilitySet) {
+  if (!agentInfo.category || availabilitySet === undefined)
+    return;
+  const resolved = resolveSourceModel(agentInfo.category, availabilitySet);
+  target.model = `${resolved.provider}/${resolved.model}`;
+  if (resolved.variant !== undefined) {
+    target.variant = resolved.variant;
+  } else {
+    delete target.variant;
   }
-  if (hasPermissionOverlay) {
-    const permission = permissionFromRules(permissionRules);
-    if (permission) {
-      result.permission = permission;
-    } else {
-      delete result.permission;
-    }
+}
+function applyAgentOverlay(target, overlay, permissionRules) {
+  if (overlay === undefined)
+    return;
+  applyOverlayObjectWithVariantClearing(target, overlay, permissionRules);
+}
+function applyPermissionOverlay(target, permissionRules, hasPermissionOverlay) {
+  if (!hasPermissionOverlay)
+    return;
+  const permission = permissionFromRules(permissionRules);
+  if (permission) {
+    target.permission = permission;
+  } else {
+    delete target.permission;
   }
-  return result;
 }
 function overlayControlsPermission(overlay) {
   return overlay !== undefined && (Object.hasOwn(overlay, "permission") || Object.hasOwn(overlay, "skills"));
@@ -1055,6 +1084,7 @@ function createConfigHandler(deps) {
     const { config: systematicConfig, overlays } = loadConfigWithSources(directory);
     const existingAgents = { ...config.agent ?? {} };
     const existingCommands = { ...config.command ?? {} };
+    const nativeAgents = Object.fromEntries(Object.entries(existingAgents).filter(([, agent]) => !isSystematicAgentConfig(agent)));
     const bundledSkills = collectSkillsAsCommands(bundledSkillsDir, systematicConfig.disabled_skills);
     const enabledSkillNames = collectEnabledSkillNames(bundledSkillsDir, systematicConfig.disabled_skills);
     const inventory = buildBundledAgentInventory(bundledAgentsDir2, systematicConfig.disabled_agents);
@@ -1062,35 +1092,46 @@ function createConfigHandler(deps) {
     const validatedOverlays = validateAgentOverlays({
       inventory,
       overlays,
-      nativeAgents: existingAgents,
+      nativeAgents,
       enabledSkills: enabledSkillNames
     });
     const resolvedOverlays = resolveAgentOverlaySet(validatedOverlays);
     const availability = deps.client ? await getAvailableModels(deps.client) : undefined;
     const availabilitySet = availability && availability.status !== "unknown" ? availability.models : undefined;
-    const bundledAgents = collectAgents(bundledAgentsDir2, systematicConfig.disabled_agents, existingAgents, resolvedOverlays, availabilitySet);
+    const bundledAgents = collectAgents(bundledAgentsDir2, systematicConfig.disabled_agents, nativeAgents, resolvedOverlays, availabilitySet);
     const bundledCommands = collectCommands(bundledCommandsDir, systematicConfig.disabled_commands);
-    config.agent = {
-      ...bundledAgents,
-      ...existingAgents
-    };
-    config.command = {
-      ...bundledCommands,
-      ...bundledSkills,
-      ...existingCommands
-    };
+    const bundledAgentKeys = new Set(Object.keys(bundledAgents));
+    config.agent = mergeSystematicEntries(existingAgents, bundledAgents, (key, agent) => bundledAgentKeys.has(key) && isSystematicAgentConfig(agent));
+    const emittedCommands = { ...bundledCommands, ...bundledSkills };
+    const emittedCommandKeys = new Set(Object.keys(emittedCommands));
+    config.command = mergeSystematicEntries(existingCommands, emittedCommands, (key, command) => isSystematicCommandConfig(command) && (emittedCommandKeys.has(key) || isSystematicOwnedCommandKey(key)));
     registerSkillsPaths(config, bundledSkillsDir);
   };
 }
 function registerSkillsPaths(config, skillsDir) {
   const extended = config;
   const paths = extended.skills?.paths ?? [];
-  const nextPaths = paths.includes(skillsDir) ? [...paths] : [...paths, skillsDir];
+  const nextPaths = removeSystematicSkillPaths(paths);
+  if (!nextPaths.includes(skillsDir))
+    nextPaths.push(skillsDir);
   extended.skills = {
     ...extended.skills,
     paths: nextPaths
   };
 }
+function removeSystematicSkillPaths(paths) {
+  return paths.filter((path6) => !isSystematicSkillPath(path6));
+}
+function isSystematicSkillPath(path6) {
+  const normalizedPath = normalizePath(path6);
+  return normalizedPath.endsWith("/.config/opencode/systematic/skills") || normalizedPath.endsWith("/.cache/opencode/systematic/skills") || normalizedPath.endsWith("/.local/share/opencode/systematic/skills") || normalizedPath.endsWith("/.opencode/systematic/skills") || /(?:^|\/)\.cache\/opencode\/packages\/@fro\.bot\/systematic@[^/]+\/node_modules\/@fro\.bot\/systematic\/skills(?:$|\/)/u.test(normalizedPath);
+}
+function normalizePath(path6) {
+  return path6.replaceAll("\\", "/").replace(/\/+$/u, "");
+}
+function isSystematicOwnedCommandKey(key) {
+  return key.startsWith("systematic:") || key.startsWith("ce:");
+}
 
 // src/lib/skill-tool.ts
 import fs4 from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fro.bot/systematic",
-  "version": "2.14.1",
+  "version": "2.14.2",
   "description": "Structured engineering workflows for OpenCode",
   "type": "module",
   "homepage": "https://fro.bot/systematic",