@evref-bl/dev-nexus 0.1.0-alpha.0

package/dist/nexusPluginCapabilities.d.ts

@@ -0,0 +1,197 @@
+export type NexusPluginCapabilityKind = "projected_skill" | "mcp_server" | "setup_obligation" | "environment_hint" | "cleanup_hook" | "agent_affordance" | "dependency_projection" | "worker_context_fragment" | "worker_briefing_fragment";
+export type NexusPluginWorkerFragmentCapabilityKind = "worker_context_fragment" | "worker_briefing_fragment";
+export type NexusPluginCleanupHookTrigger = "before_run" | "after_run" | "manual";
+export type NexusPluginDependencyProjectionSourceControl = "support" | "source";
+export declare const nexusPluginWorkerFragmentTitleMaxLength = 160;
+export declare const nexusPluginWorkerFragmentBodyMaxLength = 4000;
+export declare const nexusPluginWorkerFragmentProvenanceMaxLength = 240;
+export interface NexusPluginCapabilityBase {
+    kind: NexusPluginCapabilityKind;
+    id: string;
+    description?: string;
+}
+export interface NexusPluginProjectedSkillCapability extends NexusPluginCapabilityBase {
+    kind: "projected_skill";
+    skillId: string;
+    targetAgents?: string[];
+}
+export interface NexusPluginMcpToolCapability {
+    name: string;
+    description?: string;
+}
+export interface NexusPluginMcpServerCapability extends NexusPluginCapabilityBase {
+    kind: "mcp_server";
+    serverName: string;
+    tools?: NexusPluginMcpToolCapability[];
+}
+export interface NexusPluginSetupObligationCapability extends NexusPluginCapabilityBase {
+    kind: "setup_obligation";
+    description: string;
+    required?: boolean;
+}
+export interface NexusPluginEnvironmentHintCapability extends NexusPluginCapabilityBase {
+    kind: "environment_hint";
+    variable: string;
+    valueHint?: string;
+    required?: boolean;
+}
+export interface NexusPluginCleanupHookCapability extends NexusPluginCapabilityBase {
+    kind: "cleanup_hook";
+    description: string;
+    trigger?: NexusPluginCleanupHookTrigger;
+    required?: boolean;
+}
+export interface NexusPluginAgentAffordanceCapability extends NexusPluginCapabilityBase {
+    kind: "agent_affordance";
+    description: string;
+}
+export interface NexusPluginDependencyProjectionCapability extends NexusPluginCapabilityBase {
+    kind: "dependency_projection";
+    source: string;
+    target: string;
+    required?: boolean;
+    sourceControl?: NexusPluginDependencyProjectionSourceControl;
+    targetAgents?: string[];
+    targetComponents?: string[];
+    reason?: string;
+}
+export interface NexusPluginWorkerFragmentCapability extends NexusPluginCapabilityBase {
+    kind: NexusPluginWorkerFragmentCapabilityKind;
+    title: string;
+    body: string;
+    targetAgents?: string[];
+    targetComponents?: string[];
+    provenance: string;
+}
+export type NexusPluginCapabilityRecord = NexusPluginProjectedSkillCapability | NexusPluginMcpServerCapability | NexusPluginSetupObligationCapability | NexusPluginEnvironmentHintCapability | NexusPluginCleanupHookCapability | NexusPluginAgentAffordanceCapability | NexusPluginDependencyProjectionCapability | NexusPluginWorkerFragmentCapability;
+export interface NexusProjectPluginConfig {
+    id: string;
+    enabled: boolean;
+    name?: string;
+    version?: string;
+    capabilities: NexusPluginCapabilityRecord[];
+}
+export type NexusProjectPluginsConfig = NexusProjectPluginConfig[];
+export type NexusPluginCapabilityProjectionRecord = {
+    kind: "projected_skill";
+    id: string;
+    description: string | null;
+    skillId: string;
+    targetAgents: string[];
+} | {
+    kind: "mcp_server";
+    id: string;
+    description: string | null;
+    serverName: string;
+    tools: Array<{
+        name: string;
+        description: string | null;
+    }>;
+} | {
+    kind: "setup_obligation";
+    id: string;
+    description: string;
+    required: boolean;
+} | {
+    kind: "environment_hint";
+    id: string;
+    description: string | null;
+    variable: string;
+    valueHint: string | null;
+    required: boolean;
+} | {
+    kind: "cleanup_hook";
+    id: string;
+    description: string;
+    trigger: NexusPluginCleanupHookTrigger | null;
+    required: boolean;
+} | {
+    kind: "agent_affordance";
+    id: string;
+    description: string;
+} | {
+    kind: "dependency_projection";
+    id: string;
+    description: string | null;
+    source: string;
+    target: string;
+    required: boolean;
+    sourceControl: NexusPluginDependencyProjectionSourceControl;
+    targetAgents: string[];
+    targetComponents: string[];
+    reason: string | null;
+} | {
+    kind: NexusPluginWorkerFragmentCapabilityKind;
+    id: string;
+    description: string | null;
+    title: string;
+    body: string;
+    targetAgents: string[];
+    targetComponents: string[];
+    provenance: string;
+    advisory: true;
+};
+export interface NexusPluginCapabilityProjection {
+    pluginId: string;
+    pluginName: string | null;
+    version: string | null;
+    capabilityCount: number;
+    capabilities: NexusPluginCapabilityProjectionRecord[];
+}
+export interface NexusPluginWorkerFragmentSource {
+    pluginId: string;
+    pluginName: string | null;
+    version: string | null;
+    capabilityId: string;
+}
+export interface NexusPluginWorkerFragmentProjection {
+    kind: NexusPluginWorkerFragmentCapabilityKind;
+    id: string;
+    title: string;
+    body: string;
+    provenance: string;
+    advisory: true;
+    targetAgents: string[];
+    targetComponents: string[];
+    source: NexusPluginWorkerFragmentSource;
+}
+export interface NexusPluginWorkerFragmentsProjection {
+    context: NexusPluginWorkerFragmentProjection[];
+    briefing: NexusPluginWorkerFragmentProjection[];
+}
+export interface ProjectPluginWorkerFragmentsOptions {
+    componentId?: string | null;
+    agent?: string | null;
+}
+export interface NexusPluginDependencyProjectionSource {
+    pluginId: string;
+    pluginName: string | null;
+    version: string | null;
+    capabilityId: string;
+}
+export interface NexusPluginDependencyProjection {
+    kind: "dependency_projection";
+    id: string;
+    description: string | null;
+    source: string;
+    target: string;
+    required: boolean;
+    sourceControl: NexusPluginDependencyProjectionSourceControl;
+    targetAgents: string[];
+    targetComponents: string[];
+    reason: string | null;
+    pluginSource: NexusPluginDependencyProjectionSource;
+}
+export interface ProjectPluginDependencyProjectionsOptions {
+    componentId?: string | null;
+    agent?: string | null;
+}
+export declare function projectPluginCapabilityProjections(config: {
+    plugins?: NexusProjectPluginsConfig;
+}): NexusPluginCapabilityProjection[];
+export declare function projectPluginWorkerFragments(config: {
+    plugins?: NexusProjectPluginsConfig;
+}, options?: ProjectPluginWorkerFragmentsOptions): NexusPluginWorkerFragmentsProjection;
+export declare function projectPluginDependencyProjections(config: {
+    plugins?: NexusProjectPluginsConfig;
+}, options?: ProjectPluginDependencyProjectionsOptions): NexusPluginDependencyProjection[];

package/dist/nexusPluginCapabilities.js

@@ -0,0 +1,201 @@
+export const nexusPluginWorkerFragmentTitleMaxLength = 160;
+export const nexusPluginWorkerFragmentBodyMaxLength = 4000;
+export const nexusPluginWorkerFragmentProvenanceMaxLength = 240;
+export function projectPluginCapabilityProjections(config) {
+    return (config.plugins ?? [])
+        .filter((plugin) => plugin.enabled !== false)
+        .map((plugin) => {
+        const capabilities = plugin.capabilities.map(projectCapabilityRecord);
+        return {
+            pluginId: plugin.id,
+            pluginName: plugin.name ?? null,
+            version: plugin.version ?? null,
+            capabilityCount: capabilities.length,
+            capabilities,
+        };
+    });
+}
+export function projectPluginWorkerFragments(config, options = {}) {
+    const fragments = (config.plugins ?? [])
+        .filter((plugin) => plugin.enabled !== false)
+        .flatMap((plugin) => plugin.capabilities
+        .filter(isWorkerFragmentCapability)
+        .filter((capability) => workerFragmentMatchesScope(capability, options))
+        .map((capability) => projectWorkerFragment(plugin, capability)))
+        .sort(compareProjectedWorkerFragments);
+    return {
+        context: fragments.filter((fragment) => fragment.kind === "worker_context_fragment"),
+        briefing: fragments.filter((fragment) => fragment.kind === "worker_briefing_fragment"),
+    };
+}
+export function projectPluginDependencyProjections(config, options = {}) {
+    return (config.plugins ?? [])
+        .filter((plugin) => plugin.enabled !== false)
+        .flatMap((plugin) => plugin.capabilities
+        .filter(isDependencyProjectionCapability)
+        .filter((capability) => dependencyProjectionMatchesScope(capability, options))
+        .map((capability) => projectDependencyProjection(plugin, capability)))
+        .sort(compareProjectedDependencyProjections);
+}
+function projectCapabilityRecord(capability) {
+    if (capability.kind === "projected_skill") {
+        return {
+            kind: capability.kind,
+            id: capability.id,
+            description: capability.description ?? null,
+            skillId: capability.skillId,
+            targetAgents: capability.targetAgents ?? [],
+        };
+    }
+    if (capability.kind === "mcp_server") {
+        return {
+            kind: capability.kind,
+            id: capability.id,
+            description: capability.description ?? null,
+            serverName: capability.serverName,
+            tools: (capability.tools ?? []).map((tool) => ({
+                name: tool.name,
+                description: tool.description ?? null,
+            })),
+        };
+    }
+    if (capability.kind === "setup_obligation") {
+        return {
+            kind: capability.kind,
+            id: capability.id,
+            description: capability.description,
+            required: capability.required ?? false,
+        };
+    }
+    if (capability.kind === "environment_hint") {
+        return {
+            kind: capability.kind,
+            id: capability.id,
+            description: capability.description ?? null,
+            variable: capability.variable,
+            valueHint: capability.valueHint ?? null,
+            required: capability.required ?? false,
+        };
+    }
+    if (capability.kind === "cleanup_hook") {
+        return {
+            kind: capability.kind,
+            id: capability.id,
+            description: capability.description,
+            trigger: capability.trigger ?? null,
+            required: capability.required ?? false,
+        };
+    }
+    if (isDependencyProjectionCapability(capability)) {
+        return {
+            kind: capability.kind,
+            id: capability.id,
+            description: capability.description ?? null,
+            source: capability.source,
+            target: capability.target,
+            required: capability.required ?? false,
+            sourceControl: capability.sourceControl ?? "support",
+            targetAgents: capability.targetAgents ?? [],
+            targetComponents: capability.targetComponents ?? [],
+            reason: capability.reason ?? null,
+        };
+    }
+    if (isWorkerFragmentCapability(capability)) {
+        return {
+            kind: capability.kind,
+            id: capability.id,
+            description: capability.description ?? null,
+            title: capability.title,
+            body: capability.body,
+            targetAgents: capability.targetAgents ?? [],
+            targetComponents: capability.targetComponents ?? [],
+            provenance: capability.provenance,
+            advisory: true,
+        };
+    }
+    return {
+        kind: capability.kind,
+        id: capability.id,
+        description: capability.description,
+    };
+}
+function projectDependencyProjection(plugin, capability) {
+    return {
+        kind: capability.kind,
+        id: capability.id,
+        description: capability.description ?? null,
+        source: capability.source,
+        target: capability.target,
+        required: capability.required ?? false,
+        sourceControl: capability.sourceControl ?? "support",
+        targetAgents: capability.targetAgents ?? [],
+        targetComponents: capability.targetComponents ?? [],
+        reason: capability.reason ?? null,
+        pluginSource: {
+            pluginId: plugin.id,
+            pluginName: plugin.name ?? null,
+            version: plugin.version ?? null,
+            capabilityId: capability.id,
+        },
+    };
+}
+function projectWorkerFragment(plugin, capability) {
+    return {
+        kind: capability.kind,
+        id: capability.id,
+        title: capability.title,
+        body: capability.body,
+        provenance: capability.provenance,
+        advisory: true,
+        targetAgents: capability.targetAgents ?? [],
+        targetComponents: capability.targetComponents ?? [],
+        source: {
+            pluginId: plugin.id,
+            pluginName: plugin.name ?? null,
+            version: plugin.version ?? null,
+            capabilityId: capability.id,
+        },
+    };
+}
+function isDependencyProjectionCapability(capability) {
+    return capability.kind === "dependency_projection";
+}
+function isWorkerFragmentCapability(capability) {
+    return (capability.kind === "worker_context_fragment" ||
+        capability.kind === "worker_briefing_fragment");
+}
+function dependencyProjectionMatchesScope(capability, options) {
+    return (targetMatches(capability.targetComponents, options.componentId) &&
+        targetMatches(capability.targetAgents, options.agent));
+}
+function workerFragmentMatchesScope(capability, options) {
+    return (targetMatches(capability.targetComponents, options.componentId) &&
+        targetMatches(capability.targetAgents, options.agent));
+}
+function targetMatches(targets, activeTarget) {
+    if (!targets || targets.length === 0 || !activeTarget) {
+        return true;
+    }
+    return targets.includes(activeTarget);
+}
+function compareProjectedDependencyProjections(left, right) {
+    return (compareStrings(left.pluginSource.pluginId, right.pluginSource.pluginId) ||
+        compareStrings(left.id, right.id) ||
+        compareStrings(left.source, right.source) ||
+        compareStrings(left.target, right.target));
+}
+function compareProjectedWorkerFragments(left, right) {
+    return (compareStrings(left.source.pluginId, right.source.pluginId) ||
+        compareStrings(left.id, right.id) ||
+        compareStrings(left.kind, right.kind) ||
+        compareStrings(left.provenance, right.provenance));
+}
+function compareStrings(left, right) {
+    if (left < right) {
+        return -1;
+    }
+    if (left > right) {
+        return 1;
+    }
+    return 0;
+}

package/dist/nexusProjectConfig.d.ts

@@ -0,0 +1,95 @@
+import type { WorkTrackingConfig } from "./workTrackingTypes.js";
+import type { NexusProjectSkillsConfig, NexusSkillSourceControl } from "./nexusSkills.js";
+import { type NexusProjectPluginsConfig } from "./nexusPluginCapabilities.js";
+import { type NexusAutomationConfig, type NexusAutomationPublicationConfig, type NexusAutomationVerificationConfig } from "./nexusAutomationConfig.js";
+export declare const devNexusProjectConfigFileName = "dev-nexus.project.json";
+export declare const nexusProjectWorktreesDirectoryName = "worktrees";
+export type NexusProjectRepoKind = "local" | "git";
+export interface NexusProjectRepoConfig {
+    kind: NexusProjectRepoKind;
+    remoteUrl: string | null;
+    defaultBranch: string | null;
+    sourceRoot?: string;
+}
+export type NexusProjectComponentRole = "primary" | "extension" | "addon" | "dependency" | "optional";
+export type NexusProjectComponentRelationshipKind = "extends" | "depends_on" | "optional" | "related";
+export interface NexusProjectComponentRelationshipConfig {
+    kind: NexusProjectComponentRelationshipKind;
+    componentId: string;
+}
+export interface NexusProjectComponentConfig {
+    id: string;
+    name: string;
+    kind: NexusProjectRepoKind;
+    role: NexusProjectComponentRole;
+    remoteUrl: string | null;
+    defaultBranch: string | null;
+    sourceRoot?: string;
+    worktreesRoot?: string;
+    workTracking?: WorkTrackingConfig;
+    verification?: Partial<NexusAutomationVerificationConfig>;
+    publication?: Partial<NexusAutomationPublicationConfig>;
+    relationships: NexusProjectComponentRelationshipConfig[];
+}
+export interface NexusAgentConfig {
+    executor?: string;
+    model?: string;
+    reasoning?: string;
+}
+export interface NexusProjectKanbanConfig {
+    provider: "vibe-kanban";
+    projectId: string | null;
+}
+export type NexusProjectExtensionsConfig = Record<string, Record<string, unknown>>;
+export interface NexusProjectAgentMcpTarget {
+    agent: string;
+    enabled?: boolean;
+    configPath?: string;
+    sourceControl?: NexusSkillSourceControl;
+    serverName?: string;
+    command?: string;
+    args?: string[];
+}
+export interface NexusProjectMcpConfig {
+    enabled?: boolean;
+    sourceControl?: NexusSkillSourceControl;
+    serverName?: string;
+    command?: string;
+    args?: string[];
+    agentTargets?: NexusProjectAgentMcpTarget[];
+}
+export interface NexusProjectConfig {
+    version: 1;
+    id: string;
+    name: string;
+    home: string | null;
+    repo: NexusProjectRepoConfig;
+    components: NexusProjectComponentConfig[];
+    worktreesRoot: string;
+    kanban: NexusProjectKanbanConfig;
+    workTracking?: WorkTrackingConfig;
+    extensions?: NexusProjectExtensionsConfig;
+    agent?: NexusAgentConfig;
+    mcp?: NexusProjectMcpConfig;
+    skills?: NexusProjectSkillsConfig;
+    plugins?: NexusProjectPluginsConfig;
+    automation?: NexusAutomationConfig;
+}
+export interface ResolveNexusAgentConfigOptions {
+    issue?: NexusAgentConfig;
+    project?: Pick<NexusProjectConfig, "agent"> | NexusAgentConfig;
+    home?: {
+        agent?: NexusAgentConfig;
+    } | NexusAgentConfig;
+    fallback?: NexusAgentConfig;
+}
+export declare class NexusConfigError extends Error {
+    constructor(message: string);
+}
+export declare function projectConfigPath(projectRootPath: string): string;
+export declare function projectWorktreesRootPath(projectRootPath: string, config?: Pick<NexusProjectConfig, "worktreesRoot">): string;
+export declare function validateNexusAgentConfig(value: unknown, pathName: string): NexusAgentConfig | undefined;
+export declare function resolveNexusAgentConfig(options: ResolveNexusAgentConfigOptions): NexusAgentConfig;
+export declare function validateProjectConfig(value: unknown): NexusProjectConfig;
+export declare function loadProjectConfig(projectRootPath: string): NexusProjectConfig;
+export declare function saveProjectConfig(projectRootPath: string, config: NexusProjectConfig): string;