@kuznai/inception-engine 0.18.0 → 0.20.0

package/dist/src/core/capabilities.js

@@ -0,0 +1,280 @@
+import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
+function resolveAgentRulesSupport(agentId, scope) {
+    const agent = AGENT_REGISTRY_BY_ID[agentId];
+    if (scope === "repo") {
+        return agent?.agentRulesRepoSupport ?? agent?.agentRulesSupport;
+    }
+    if (scope === "workspace") {
+        return (agent?.agentRulesWorkspaceSupport ??
+            agent?.agentRulesRepoSupport ??
+            agent?.agentRulesSupport);
+    }
+    return agent?.agentRulesSupport;
+}
+function resolveMcpSupport(agentId, scope) {
+    const agent = AGENT_REGISTRY_BY_ID[agentId];
+    if (scope === "repo") {
+        return agent?.mcpRepoSupport ?? agent?.mcpSupport;
+    }
+    if (scope === "workspace") {
+        return (agent?.mcpWorkspaceSupport ?? agent?.mcpRepoSupport ?? agent?.mcpSupport);
+    }
+    return agent?.mcpSupport;
+}
+function resolveAgentDefinitionsSupport(agentId, scope) {
+    const agent = AGENT_REGISTRY_BY_ID[agentId];
+    if (scope === "repo") {
+        return agent?.agentDefinitionsRepoSupport ?? agent?.agentDefinitionsSupport;
+    }
+    if (scope === "workspace") {
+        return (agent?.agentDefinitionsWorkspaceSupport ??
+            agent?.agentDefinitionsRepoSupport ??
+            agent?.agentDefinitionsSupport);
+    }
+    return agent?.agentDefinitionsSupport;
+}
+function capabilityLabel(capability) {
+    switch (capability) {
+        case "skills":
+            return "skills";
+        case "mcpServers":
+            return "mcpServers";
+        case "agentRules":
+            return "agentRules";
+        case "permissions":
+            return "permissions";
+        case "agentDefinitions":
+            return "agentDefinitions";
+    }
+}
+function capabilitySurfaceLabel(capability) {
+    switch (capability) {
+        case "skills":
+            return "skill";
+        case "mcpServers":
+            return "MCP";
+        case "agentRules":
+            return "rules";
+        case "permissions":
+            return "permissions";
+        case "agentDefinitions":
+            return "agent-definitions";
+    }
+}
+function resolveSkillsCapability(agentId) {
+    const agent = AGENT_REGISTRY_BY_ID[agentId];
+    if (agent.skills) {
+        return {
+            agentId,
+            capability: "skills",
+            supportStatus: "supported",
+            confidence: agent.provenance.skills ?? "provisional",
+            schemaLabel: "dedicated skill directory",
+            surfaceKind: "agent-specific",
+            requiresPrimary: false,
+            canDeployDirectlyWhenPrimaryAbsent: true,
+            includeInInitByDefault: true,
+        };
+    }
+    const via = agent.skillsSurfaceKind?.via;
+    return {
+        agentId,
+        capability: "skills",
+        supportStatus: "supported",
+        confidence: agent.provenance.skills,
+        schemaLabel: "shared native skill directory",
+        surfaceKind: agent.skillsSurfaceKind?.kind === "shared-via" ? "shared-via" : "native",
+        sharedVia: via,
+        requiresPrimary: true,
+        canDeployDirectlyWhenPrimaryAbsent: false,
+        includeInInitByDefault: false,
+    };
+}
+function getSurfaceRecordAndConfidence(agentId, capability, scope) {
+    const agent = AGENT_REGISTRY_BY_ID[agentId];
+    if (capability === "mcpServers") {
+        return {
+            supportRecord: resolveMcpSupport(agentId, scope),
+            confidence: agent.provenance.mcpConfig,
+        };
+    }
+    if (capability === "agentRules") {
+        return {
+            supportRecord: resolveAgentRulesSupport(agentId, scope),
+            confidence: agent.provenance.agentRules,
+        };
+    }
+    if (capability === "permissions") {
+        return {
+            supportRecord: agent.permissionsSupport,
+            confidence: agent.provenance.permissions,
+        };
+    }
+    return {
+        supportRecord: resolveAgentDefinitionsSupport(agentId, scope),
+        confidence: agent.provenance.agentDefinitions,
+    };
+}
+function resolveUnsupportedSurface(agentId, capability, supportRecord, confidence) {
+    return {
+        agentId,
+        capability,
+        supportStatus: "unsupported",
+        supportRecord,
+        confidence,
+        schemaLabel: supportRecord?.schemaLabel ?? "an unsupported surface",
+        surfaceKind: "agent-specific",
+        requiresPrimary: false,
+        canDeployDirectlyWhenPrimaryAbsent: false,
+        includeInInitByDefault: false,
+        reason: supportRecord?.status === "unsupported"
+            ? supportRecord.reason
+            : undefined,
+    };
+}
+function resolvePlannedSurface(agentId, capability, supportRecord, confidence) {
+    return {
+        agentId,
+        capability,
+        supportStatus: "planned",
+        supportRecord,
+        confidence,
+        schemaLabel: supportRecord.schemaLabel,
+        surfaceKind: "agent-specific",
+        requiresPrimary: false,
+        canDeployDirectlyWhenPrimaryAbsent: false,
+        includeInInitByDefault: false,
+        reason: supportRecord.reason,
+        plannedSurface: supportRecord.plannedSurface,
+    };
+}
+function resolveSupportedSurface(agentId, capability, supportRecord, confidence) {
+    const surfaceKind = supportRecord.surfaceKind?.kind ?? "agent-specific";
+    const sharedVia = supportRecord.surfaceKind?.kind === "shared-via"
+        ? supportRecord.surfaceKind.via
+        : undefined;
+    const requiresPrimary = supportRecord.surfaceKind?.kind === "shared-via" &&
+        supportRecord.surfaceKind.requiresPrimary === true;
+    return {
+        agentId,
+        capability,
+        supportStatus: "supported",
+        support: supportRecord,
+        supportRecord,
+        confidence: confidence ?? "provisional",
+        schemaLabel: supportRecord.schemaLabel,
+        surfaceKind,
+        sharedVia,
+        requiresPrimary,
+        canDeployDirectlyWhenPrimaryAbsent: surfaceKind !== "shared-via" || !requiresPrimary,
+        includeInInitByDefault: surfaceKind === "agent-specific",
+    };
+}
+export function resolveCapabilitySurface(agentId, capability, scope = "global") {
+    if (capability === "skills")
+        return resolveSkillsCapability(agentId);
+    const { supportRecord, confidence } = getSurfaceRecordAndConfidence(agentId, capability, scope);
+    if (!supportRecord || supportRecord.status === "unsupported") {
+        return resolveUnsupportedSurface(agentId, capability, supportRecord, confidence);
+    }
+    if (supportRecord.status === "planned") {
+        return resolvePlannedSurface(agentId, capability, supportRecord, confidence);
+    }
+    return resolveSupportedSurface(agentId, capability, supportRecord, confidence);
+}
+function createSurfaceWarning(surface, entryName) {
+    const label = capabilityLabel(surface.capability);
+    if (surface.supportStatus === "unsupported") {
+        return {
+            kind: "confidence",
+            message: `${label}: agent "${surface.agentId}" uses ${surface.schemaLabel} (unsupported) and ${surface.reason ?? "does not expose a supported adapter"} — skipping "${entryName}"`,
+        };
+    }
+    if (surface.supportStatus === "planned") {
+        return {
+            kind: "confidence",
+            message: `${label}: agent "${surface.agentId}" ${capabilitySurfaceLabel(surface.capability)} support is planned via ${surface.plannedSurface} — skipping "${entryName}" until that surface is implemented`,
+        };
+    }
+    if (surface.surfaceKind === "shared-via" && surface.sharedVia) {
+        return {
+            kind: "confidence",
+            message: `${label}: agent "${surface.agentId}" reads this surface via "${surface.sharedVia}" — add "${surface.sharedVia}" to the entry's agents list to deploy to this surface, or deploy via the "${surface.sharedVia}" ${label} target instead`,
+        };
+    }
+    return {
+        kind: "confidence",
+        message: `${label}: agent "${surface.agentId}" does not expose a directly deployable surface — skipping "${entryName}"`,
+    };
+}
+export function planCapabilityForDeploy(opts) {
+    const surface = resolveCapabilitySurface(opts.agentId, opts.capability, opts.scope);
+    if (surface.supportStatus !== "supported") {
+        return {
+            outcome: "warn",
+            warning: createSurfaceWarning(surface, opts.entryName),
+        };
+    }
+    if (surface.surfaceKind === "native") {
+        return { outcome: "native" };
+    }
+    if (surface.surfaceKind === "shared-via" && surface.sharedVia) {
+        if (opts.targetAgentIds.includes(surface.sharedVia)) {
+            return {
+                outcome: "redundant",
+                confidence: surface.confidence,
+                support: surface.support,
+                sharedVia: surface.sharedVia,
+            };
+        }
+        if (!surface.canDeployDirectlyWhenPrimaryAbsent) {
+            return {
+                outcome: "warn",
+                warning: createSurfaceWarning(surface, opts.entryName),
+            };
+        }
+    }
+    return {
+        outcome: "action",
+        confidence: surface.confidence,
+        support: surface.support,
+    };
+}
+export function shouldInitIncludeAgent(agentId, capability, scope = "global") {
+    return resolveCapabilitySurface(agentId, capability, scope)
+        .includeInInitByDefault;
+}
+export function describeCapabilityConfidence(agentId, capability, scope = "global") {
+    const surface = resolveCapabilitySurface(agentId, capability, scope);
+    if (surface.supportStatus === "planned") {
+        return {
+            confidence: surface.confidence,
+            message: `Agent "${agentId}" ${capabilitySurfaceLabel(capability)} support remains planned via ${surface.plannedSurface}.`,
+        };
+    }
+    if (surface.supportStatus === "unsupported") {
+        return {
+            confidence: surface.confidence,
+            message: `Agent "${agentId}" ${capabilitySurfaceLabel(capability)} surface is unsupported: ${surface.reason ?? surface.schemaLabel}.`,
+        };
+    }
+    if (surface.surfaceKind === "shared-via" && surface.sharedVia) {
+        return {
+            confidence: surface.confidence,
+            message: `Agent "${agentId}" ${capabilitySurfaceLabel(capability)} surface is shared through "${surface.sharedVia}"${surface.requiresPrimary ? " and requires the primary target to deploy" : ""}.`,
+        };
+    }
+    if (surface.confidence === "implementation-only") {
+        return {
+            confidence: surface.confidence,
+            message: `Agent "${agentId}" ${capabilitySurfaceLabel(capability)} support is implementation-only: behavior is based on registry inspection and local validation, not published documentation.`,
+        };
+    }
+    if (surface.confidence === "provisional") {
+        return {
+            confidence: surface.confidence,
+            message: `Agent "${agentId}" ${capabilitySurfaceLabel(capability)} support is provisional: behavior has not been independently verified.`,
+        };
+    }
+    return { confidence: surface.confidence, message: null };
+}

package/dist/{core → src/core}/deploy.d.ts

@@ -1,6 +1,6 @@
 import type { AgentId, DeployAction, Manifest, PlannedChange, PlanWarning, SkillDirDeployAction } from "../types.ts";
 import { type RegistryPersistence } from "./ownership.ts";
-export declare function planDeploy(manifest: Manifest, sourceDir: string, detectedAgents: AgentId[], home: string): Promise<{
+export declare function planDeploy(manifest: Manifest, sourceDir: string, detectedAgents: AgentId[], home: string, repo?: string, workspace?: string): Promise<{
     actions: DeployAction[];
     warnings: PlanWarning[];
 }>;