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

package/dist/nexusProjectOperations.js

@@ -0,0 +1,296 @@
+import fs from "node:fs";
+import path from "node:path";
+import { nexusProjectWorktreesDirectoryName, loadProjectConfig, projectConfigPath, projectWorktreesRootPath, saveProjectConfig, } from "./nexusProjectConfig.js";
+import { assertFileDoesNotExist, assertGitRepository, defaultImportedProjectRoot, defaultProjectGitRunner, defaultSourceCheckoutDirectoryName, detectDefaultBranch, detectOriginUrl, directoryExistsAndIsNonEmpty, ensureUniqueProject, loadProjectConfigIfExists, NexusProjectError, optionalNonEmptyString, pathForProjectConfig, runProjectGitCommand, safeProjectDirectoryName, slugify, } from "./nexusProjectLifecycle.js";
+import { findNexusProjectReference, projectRootFromInput, upsertNexusProjectReference, } from "./nexusProjectRegistry.js";
+import { scaffoldNexusProject, } from "./nexusProjectScaffold.js";
+export function buildProjectConfig(name, projectId, from, defaultBranch, vibeKanbanProjectId = null, sourceRoot, forceGit = false, extensions) {
+    const repo = {
+        kind: from || sourceRoot || forceGit ? "git" : "local",
+        remoteUrl: from ?? null,
+        defaultBranch,
+        ...(sourceRoot ? { sourceRoot } : {}),
+    };
+    return {
+        version: 1,
+        id: projectId,
+        name,
+        home: null,
+        repo,
+        components: [
+            {
+                id: "primary",
+                name,
+                kind: repo.kind,
+                role: "primary",
+                remoteUrl: repo.remoteUrl,
+                defaultBranch: repo.defaultBranch,
+                sourceRoot: sourceRoot ?? ".",
+                relationships: [],
+            },
+        ],
+        worktreesRoot: nexusProjectWorktreesDirectoryName,
+        kanban: {
+            provider: "vibe-kanban",
+            projectId: vibeKanbanProjectId,
+        },
+        ...(extensions ? { extensions } : {}),
+    };
+}
+export function buildConfiguredWorkTracking(options) {
+    if (options.provider === "local") {
+        const storePath = optionalNonEmptyString(options.storePath, "storePath");
+        return {
+            provider: "local",
+            ...(storePath !== undefined ? { storePath } : {}),
+        };
+    }
+    if (options.provider === "github") {
+        const owner = optionalNonEmptyString(options.repositoryOwner, "repositoryOwner");
+        const name = optionalNonEmptyString(options.repositoryName, "repositoryName");
+        if (!owner) {
+            throw new NexusProjectError("repositoryOwner is required for github tracker configuration");
+        }
+        if (!name) {
+            throw new NexusProjectError("repositoryName is required for github tracker configuration");
+        }
+        const host = optionalNonEmptyString(options.host, "host");
+        return {
+            provider: "github",
+            ...(host !== undefined ? { host } : {}),
+            repository: {
+                owner,
+                name,
+            },
+        };
+    }
+    if (options.provider === "gitlab") {
+        const id = optionalNonEmptyString(options.repositoryId, "repositoryId");
+        if (!id) {
+            throw new NexusProjectError("repositoryId is required for gitlab tracker configuration");
+        }
+        const host = optionalNonEmptyString(options.host, "host");
+        return {
+            provider: "gitlab",
+            ...(host !== undefined ? { host } : {}),
+            repository: {
+                id,
+            },
+        };
+    }
+    if (options.provider === "jira") {
+        const host = optionalNonEmptyString(options.host, "host");
+        const projectKey = optionalNonEmptyString(options.projectKey, "projectKey");
+        const issueType = optionalNonEmptyString(options.issueType, "issueType");
+        if (!host) {
+            throw new NexusProjectError("host is required for jira tracker configuration");
+        }
+        if (!projectKey) {
+            throw new NexusProjectError("projectKey is required for jira tracker configuration");
+        }
+        return {
+            provider: "jira",
+            host,
+            projectKey,
+            ...(issueType !== undefined ? { issueType } : {}),
+        };
+    }
+    throw new NexusProjectError(`Unsupported tracker provider: ${options.provider}`);
+}
+export function createNexusProjectInRegistry(options) {
+    if (options.name.trim().length === 0) {
+        throw new NexusProjectError("name must be a non-empty string");
+    }
+    const vibeKanbanProjectId = optionalNonEmptyString(options.vibeKanbanProjectId, "vibeKanbanProjectId") ??
+        null;
+    if (options.from && options.gitInit) {
+        throw new NexusProjectError("--from and --git-init are mutually exclusive");
+    }
+    const projectId = slugify(options.name);
+    const projectRoot = path.resolve(options.root ??
+        path.join(options.registry.paths.projectsRoot, safeProjectDirectoryName(options.name)));
+    ensureUniqueProject(options.registry, projectId, projectRoot);
+    const creatingFromRemote = Boolean(options.from);
+    if (directoryExistsAndIsNonEmpty(projectRoot)) {
+        throw new NexusProjectError(`Project root already exists and is not empty: ${projectRoot}`);
+    }
+    const gitRunner = options.gitRunner ?? defaultProjectGitRunner;
+    const gitCommands = [];
+    let sourceRoot = null;
+    if (creatingFromRemote) {
+        fs.mkdirSync(projectRoot, { recursive: true });
+        runProjectGitCommand(gitRunner, gitCommands, ["init", projectRoot]);
+        sourceRoot = path.join(projectRoot, defaultSourceCheckoutDirectoryName);
+        runProjectGitCommand(gitRunner, gitCommands, [
+            "clone",
+            options.from,
+            sourceRoot,
+        ]);
+    }
+    else {
+        fs.mkdirSync(projectRoot, { recursive: true });
+        runProjectGitCommand(gitRunner, gitCommands, ["init", projectRoot]);
+    }
+    const defaultBranch = detectDefaultBranch(gitRunner, gitCommands, sourceRoot ?? projectRoot);
+    const projectConfig = buildProjectConfig(options.name, projectId, options.from, defaultBranch, vibeKanbanProjectId, sourceRoot ? pathForProjectConfig(projectRoot, sourceRoot) : null, false, options.extensions);
+    const devNexusProjectConfigPath = projectConfigPath(projectRoot);
+    const worktreesRoot = projectWorktreesRootPath(projectRoot, projectConfig);
+    assertFileDoesNotExist(devNexusProjectConfigPath);
+    saveProjectConfig(projectRoot, projectConfig);
+    const scaffold = scaffoldNexusProject({
+        homePath: options.homePath,
+        projectRoot,
+        worktreesRoot,
+        projectConfig,
+        skills: projectConfig.skills,
+        mcp: projectConfig.mcp,
+        extensions: options.scaffoldExtensions,
+    });
+    const reference = upsertNexusProjectReference(options.registry, projectRoot, projectConfig, { vibeKanbanProjectId });
+    return {
+        projectRoot,
+        projectConfigPath: devNexusProjectConfigPath,
+        worktreesRoot,
+        projectConfig,
+        reference,
+        scaffold,
+        git: {
+            operation: creatingFromRemote ? "clone" : "init",
+            remoteUrl: options.from ?? null,
+            defaultBranch,
+            commands: gitCommands,
+        },
+    };
+}
+export function importNexusProjectInRegistry(options) {
+    const vibeKanbanProjectId = optionalNonEmptyString(options.vibeKanbanProjectId, "vibeKanbanProjectId") ??
+        null;
+    const sourceRoot = path.resolve(options.root);
+    if (!fs.existsSync(sourceRoot) || !fs.statSync(sourceRoot).isDirectory()) {
+        throw new NexusProjectError(`Project source root must be an existing directory: ${sourceRoot}`);
+    }
+    const gitRunner = options.gitRunner ?? defaultProjectGitRunner;
+    const gitCommands = [];
+    assertGitRepository(gitRunner, gitCommands, sourceRoot);
+    const remoteUrl = detectOriginUrl(gitRunner, gitCommands, sourceRoot);
+    const defaultBranch = detectDefaultBranch(gitRunner, gitCommands, sourceRoot);
+    const existingProjectConfig = loadProjectConfigIfExists(sourceRoot);
+    const projectName = existingProjectConfig?.name ?? options.name ?? path.basename(sourceRoot);
+    const projectId = existingProjectConfig?.id ?? slugify(projectName);
+    const projectRoot = existingProjectConfig
+        ? sourceRoot
+        : path.resolve(options.projectRoot ??
+            defaultImportedProjectRoot(options.registry, projectName, sourceRoot));
+    ensureUniqueProject(options.registry, projectId, projectRoot);
+    if (!existingProjectConfig && directoryExistsAndIsNonEmpty(projectRoot)) {
+        throw new NexusProjectError(`Project root already exists and is not empty: ${projectRoot}`);
+    }
+    if (!existingProjectConfig) {
+        fs.mkdirSync(projectRoot, { recursive: true });
+        runProjectGitCommand(gitRunner, gitCommands, ["init", projectRoot]);
+    }
+    const projectConfig = existingProjectConfig
+        ? options.extensions
+            ? {
+                ...existingProjectConfig,
+                extensions: {
+                    ...existingProjectConfig.extensions,
+                    ...options.extensions,
+                },
+            }
+            : existingProjectConfig
+        : buildProjectConfig(projectName, projectId, remoteUrl ?? undefined, defaultBranch, vibeKanbanProjectId, pathForProjectConfig(projectRoot, sourceRoot), true, options.extensions);
+    if (existingProjectConfig && vibeKanbanProjectId) {
+        projectConfig.kanban = {
+            ...projectConfig.kanban,
+            projectId: vibeKanbanProjectId,
+        };
+    }
+    const devNexusProjectConfigPath = projectConfigPath(projectRoot);
+    if (!existingProjectConfig || vibeKanbanProjectId || options.extensions) {
+        saveProjectConfig(projectRoot, projectConfig);
+    }
+    const worktreesRoot = projectWorktreesRootPath(projectRoot, projectConfig);
+    const scaffold = scaffoldNexusProject({
+        homePath: options.homePath,
+        projectRoot,
+        worktreesRoot,
+        projectConfig,
+        skills: projectConfig.skills,
+        mcp: projectConfig.mcp,
+        extensions: options.scaffoldExtensions,
+    });
+    const reference = upsertNexusProjectReference(options.registry, projectRoot, projectConfig, { vibeKanbanProjectId: projectConfig.kanban.projectId });
+    return {
+        projectRoot,
+        projectConfigPath: devNexusProjectConfigPath,
+        worktreesRoot,
+        projectConfig,
+        reference,
+        scaffold,
+        git: {
+            operation: "import",
+            remoteUrl,
+            defaultBranch,
+            commands: gitCommands,
+        },
+    };
+}
+export function configureNexusProjectTrackerInRegistry(options) {
+    const existingReference = findNexusProjectReference(options.registry, options.project);
+    const projectRoot = existingReference
+        ? path.resolve(existingReference.projectRoot)
+        : projectRootFromInput(options.project);
+    const projectConfig = loadProjectConfigIfExists(projectRoot);
+    if (!projectConfig) {
+        throw new NexusProjectError(`DevNexus project is not initialized: ${projectConfigPath(projectRoot)}`);
+    }
+    const workTracking = buildConfiguredWorkTracking(options);
+    const updatedProjectConfig = {
+        ...projectConfig,
+        workTracking,
+        components: projectConfig.components.map((component) => component.role === "primary"
+            ? {
+                ...component,
+                workTracking,
+            }
+            : component),
+    };
+    const projectConfigFilePath = saveProjectConfig(projectRoot, updatedProjectConfig);
+    const reference = upsertNexusProjectReference(options.registry, projectRoot, updatedProjectConfig, { vibeKanbanProjectId: null });
+    return {
+        projectRoot,
+        projectConfigPath: projectConfigFilePath,
+        projectConfig: updatedProjectConfig,
+        reference,
+        workTracking,
+    };
+}
+export function linkNexusProjectTrackerInRegistry(options) {
+    const vibeKanbanProjectId = optionalNonEmptyString(options.trackerProjectId, "trackerProjectId");
+    if (!vibeKanbanProjectId) {
+        throw new NexusProjectError("trackerProjectId must be a non-empty string");
+    }
+    const existingReference = findNexusProjectReference(options.registry, options.project);
+    const projectRoot = existingReference
+        ? path.resolve(existingReference.projectRoot)
+        : projectRootFromInput(options.project);
+    const projectConfig = loadProjectConfig(projectRoot);
+    const updatedProjectConfig = {
+        ...projectConfig,
+        kanban: {
+            ...projectConfig.kanban,
+            projectId: vibeKanbanProjectId,
+        },
+    };
+    const projectConfigFilePath = saveProjectConfig(projectRoot, updatedProjectConfig);
+    const reference = upsertNexusProjectReference(options.registry, projectRoot, updatedProjectConfig, { vibeKanbanProjectId });
+    return {
+        projectRoot,
+        projectConfigPath: projectConfigFilePath,
+        projectConfig: updatedProjectConfig,
+        reference,
+        vibeKanbanProjectId,
+        vibeKanbanRepoId: reference.vibeKanbanRepoId ?? null,
+    };
+}

package/dist/nexusProjectRegistry.d.ts

@@ -0,0 +1,42 @@
+import { type NexusProjectConfig } from "./nexusProjectConfig.js";
+import { type ResolvedNexusProjectComponent } from "./nexusProjectLifecycle.js";
+import type { WorkTrackingConfig } from "./workTrackingTypes.js";
+export interface NexusProjectReference {
+    id: string;
+    name: string;
+    projectRoot: string;
+    vibeKanbanProjectId?: string;
+    vibeKanbanRepoId?: string;
+}
+export interface NexusProjectRegistry {
+    projects: NexusProjectReference[];
+}
+export interface NexusProjectStatusBase {
+    id: string;
+    name: string;
+    projectRoot: string;
+    repo: NexusProjectConfig["repo"] | null;
+    components: ResolvedNexusProjectComponent[];
+    workTracking: WorkTrackingConfig | null;
+    vibeKanbanProjectId: string | null;
+    vibeKanbanRepoId: string | null;
+    projectConfigPath: string;
+    projectConfigExists: boolean;
+    worktreesRoot: string;
+    worktreesRootExists: boolean;
+}
+export interface BuildNexusProjectStatusOptions {
+    projectConfig?: NexusProjectConfig;
+}
+export interface UpsertNexusProjectReferenceOptions {
+    vibeKanbanProjectId?: string | null;
+    vibeKanbanRepoId?: string | null;
+}
+export declare function projectRootFromInput(input: string): string;
+export declare function findNexusProjectReferenceById(registry: NexusProjectRegistry, id: string): NexusProjectReference | undefined;
+export declare function findNexusProjectReferenceByPath(registry: NexusProjectRegistry, projectPath: string): NexusProjectReference | undefined;
+export declare function findNexusProjectReference(registry: NexusProjectRegistry, idOrPath: string): NexusProjectReference | undefined;
+export declare function buildNexusProjectStatus(reference: NexusProjectReference, options?: BuildNexusProjectStatusOptions): NexusProjectStatusBase;
+export declare function buildNexusProjectStatusForPath(projectRoot: string): NexusProjectStatusBase;
+export declare function upsertNexusProjectReference(registry: NexusProjectRegistry, projectRoot: string, projectConfig: NexusProjectConfig, options?: UpsertNexusProjectReferenceOptions): NexusProjectReference;
+export declare function loadRequiredProjectConfig(projectRoot: string): NexusProjectConfig;

package/dist/nexusProjectRegistry.js

@@ -0,0 +1,91 @@
+import fs from "node:fs";
+import path from "node:path";
+import { devNexusProjectConfigFileName, loadProjectConfig, projectConfigPath, projectWorktreesRootPath, } from "./nexusProjectConfig.js";
+import { ensureUniqueProject, loadProjectConfigIfExists, NexusProjectError, resolveProjectComponents, samePath, } from "./nexusProjectLifecycle.js";
+export function projectRootFromInput(input) {
+    const resolved = path.resolve(input);
+    return path.basename(resolved) === devNexusProjectConfigFileName
+        ? path.dirname(resolved)
+        : resolved;
+}
+export function findNexusProjectReferenceById(registry, id) {
+    return (registry.projects.find((project) => project.id === id) ??
+        registry.projects.find((project) => loadProjectConfigIfExists(path.resolve(project.projectRoot))?.id === id));
+}
+export function findNexusProjectReferenceByPath(registry, projectPath) {
+    const projectRoot = projectRootFromInput(projectPath);
+    return registry.projects.find((project) => samePath(project.projectRoot, projectRoot));
+}
+export function findNexusProjectReference(registry, idOrPath) {
+    return (findNexusProjectReferenceById(registry, idOrPath) ??
+        findNexusProjectReferenceByPath(registry, idOrPath));
+}
+export function buildNexusProjectStatus(reference, options = {}) {
+    const projectRoot = path.resolve(reference.projectRoot);
+    const config = options.projectConfig ?? loadProjectConfigIfExists(projectRoot);
+    const resolvedProjectConfigPath = projectConfigPath(projectRoot);
+    const resolvedWorktreesRoot = projectWorktreesRootPath(projectRoot, config);
+    const components = config ? resolveProjectComponents(projectRoot, config) : [];
+    return {
+        id: config?.id ?? reference.id,
+        name: config?.name ?? reference.name,
+        projectRoot,
+        repo: config?.repo ?? null,
+        components,
+        workTracking: config?.workTracking ?? null,
+        vibeKanbanProjectId: config?.kanban.projectId ?? reference.vibeKanbanProjectId ?? null,
+        vibeKanbanRepoId: reference.vibeKanbanRepoId ?? null,
+        projectConfigPath: resolvedProjectConfigPath,
+        projectConfigExists: Boolean(config),
+        worktreesRoot: resolvedWorktreesRoot,
+        worktreesRootExists: fs.existsSync(resolvedWorktreesRoot),
+    };
+}
+export function buildNexusProjectStatusForPath(projectRoot) {
+    const config = loadProjectConfigIfExists(projectRoot);
+    if (!config) {
+        throw new NexusProjectError(`DevNexus project is not initialized: ${projectConfigPath(projectRoot)}`);
+    }
+    return buildNexusProjectStatus({
+        id: config.id,
+        name: config.name,
+        projectRoot,
+        ...(config.kanban.projectId
+            ? { vibeKanbanProjectId: config.kanban.projectId }
+            : {}),
+    }, { projectConfig: config });
+}
+export function upsertNexusProjectReference(registry, projectRoot, projectConfig, options = {}) {
+    const existingIndex = registry.projects.findIndex((project) => samePath(project.projectRoot, projectRoot));
+    const existing = existingIndex >= 0 ? registry.projects[existingIndex] : undefined;
+    const resolvedVibeKanbanProjectId = options.vibeKanbanProjectId ??
+        projectConfig.kanban.projectId ??
+        existing?.vibeKanbanProjectId ??
+        null;
+    const resolvedVibeKanbanRepoId = options.vibeKanbanRepoId ?? existing?.vibeKanbanRepoId ?? null;
+    const reference = {
+        id: projectConfig.id,
+        name: projectConfig.name,
+        projectRoot,
+        ...(resolvedVibeKanbanProjectId
+            ? { vibeKanbanProjectId: resolvedVibeKanbanProjectId }
+            : {}),
+        ...(resolvedVibeKanbanRepoId
+            ? { vibeKanbanRepoId: resolvedVibeKanbanRepoId }
+            : {}),
+    };
+    if (existingIndex >= 0) {
+        registry.projects[existingIndex] = reference;
+        return reference;
+    }
+    const duplicateId = registry.projects.find((project) => project.id === projectConfig.id);
+    if (duplicateId) {
+        throw new NexusProjectError(`Project id is already registered at another root: ${duplicateId.id}`);
+    }
+    ensureUniqueProject(registry, projectConfig.id, projectRoot);
+    registry.projects.push(reference);
+    return reference;
+}
+export function loadRequiredProjectConfig(projectRoot) {
+    return loadProjectConfig(projectRoot);
+}

package/dist/nexusProjectScaffold.d.ts

@@ -0,0 +1,25 @@
+import type { NexusExtension } from "./nexusExtension.js";
+import { type MaterializeNexusProjectAgentMcpConfigResult } from "./nexusAgentMcpConfig.js";
+import type { NexusProjectMcpConfig } from "./nexusProjectConfig.js";
+import type { NexusProjectConfig } from "./nexusProjectConfig.js";
+import { type MaterializeNexusProjectTemplateResult } from "./nexusProjectTemplate.js";
+import { type MaterializeNexusProjectSkillsResult, type NexusProjectSkillsConfig, type NexusSkillDefinition } from "./nexusSkills.js";
+export interface ScaffoldNexusProjectOptions<ProjectConfig extends NexusProjectConfig = NexusProjectConfig> {
+    homePath: string;
+    projectRoot: string;
+    worktreesRoot: string;
+    projectConfig: ProjectConfig;
+    extensions?: NexusExtension<ProjectConfig>[];
+    skills?: NexusProjectSkillsConfig | false;
+    skillDefinitions?: NexusSkillDefinition[];
+    mcp?: NexusProjectMcpConfig | false;
+}
+export interface ScaffoldNexusProjectResult {
+    projectRoot: string;
+    worktreesRoot: string;
+    template: MaterializeNexusProjectTemplateResult;
+    skills: MaterializeNexusProjectSkillsResult;
+    agentMcp: MaterializeNexusProjectAgentMcpConfigResult;
+    extensionResults: Record<string, unknown>;
+}
+export declare function scaffoldNexusProject<ProjectConfig extends NexusProjectConfig = NexusProjectConfig>(options: ScaffoldNexusProjectOptions<ProjectConfig>): ScaffoldNexusProjectResult;

package/dist/nexusProjectScaffold.js

@@ -0,0 +1,61 @@
+import { emptyNexusProjectAgentMcpConfigResult, materializeNexusProjectAgentMcpConfig, } from "./nexusAgentMcpConfig.js";
+import { materializeNexusProjectTemplate, } from "./nexusProjectTemplate.js";
+import { materializeNexusProjectSkills, } from "./nexusSkills.js";
+export function scaffoldNexusProject(options) {
+    const context = {
+        homePath: options.homePath,
+        projectRoot: options.projectRoot,
+        worktreesRoot: options.worktreesRoot,
+        projectConfig: options.projectConfig,
+    };
+    const skillsContext = context;
+    const extensionResults = {};
+    const extensionSkills = [];
+    for (const extension of options.extensions ?? []) {
+        const skills = extension.projectSkills?.(skillsContext);
+        if (skills) {
+            extensionSkills.push(...skills);
+        }
+        if (!extension.installProjectFiles) {
+            continue;
+        }
+        extensionResults[extension.id] = extension.installProjectFiles(context);
+    }
+    const template = materializeNexusProjectTemplate({
+        projectRoot: options.projectRoot,
+        worktreesRoot: options.worktreesRoot,
+        projectConfig: options.projectConfig,
+        skillsConfig: options.skills,
+        mcpConfig: options.mcp,
+    });
+    const skills = options.skills === false
+        ? {
+            skillsDirectory: "",
+            installed: [],
+            agentTargets: [],
+            gitExcludePath: null,
+            gitExcludeEntries: [],
+        }
+        : materializeNexusProjectSkills({
+            projectRoot: options.projectRoot,
+            skillsConfig: options.skills,
+            skillDefinitions: [
+                ...extensionSkills,
+                ...(options.skillDefinitions ?? []),
+            ],
+        });
+    const agentMcp = options.mcp === undefined || options.mcp === false
+        ? emptyNexusProjectAgentMcpConfigResult()
+        : materializeNexusProjectAgentMcpConfig({
+            projectRoot: options.projectRoot,
+            mcpConfig: options.mcp,
+        });
+    return {
+        projectRoot: options.projectRoot,
+        worktreesRoot: options.worktreesRoot,
+        template,
+        skills,
+        agentMcp,
+        extensionResults,
+    };
+}

package/dist/nexusProjectTemplate.d.ts

@@ -0,0 +1,34 @@
+import type { NexusProjectMcpConfig } from "./nexusProjectConfig.js";
+import { type NexusProjectConfig } from "./nexusProjectConfig.js";
+import type { NexusProjectSkillsConfig, NexusSkillSourceControl } from "./nexusSkills.js";
+export type NexusProjectTemplateArea = "project_state" | "component_configuration" | "target_state" | "skills" | "agent_mcp_projection";
+export type NexusProjectTemplateOwner = "generated" | "user_authored" | "local_runtime";
+export interface NexusProjectTemplateEntry {
+    area: NexusProjectTemplateArea;
+    owner: NexusProjectTemplateOwner;
+    path: string;
+    sourceControl: NexusSkillSourceControl | "local";
+    description: string;
+}
+export interface NexusProjectTemplateLayout {
+    entries: NexusProjectTemplateEntry[];
+    migrationNotes: string[];
+}
+export interface MaterializeNexusProjectTemplateOptions {
+    projectRoot: string;
+    worktreesRoot: string;
+    projectConfig: NexusProjectConfig;
+    skillsConfig?: NexusProjectSkillsConfig | false;
+    mcpConfig?: NexusProjectMcpConfig | false;
+    excludeFromGit?: boolean;
+}
+export interface MaterializeNexusProjectTemplateResult extends NexusProjectTemplateLayout {
+    supportReadmePath: string;
+    targetStatePath: string | null;
+    componentWorktreesRoots: string[];
+    gitExcludePath: string | null;
+    gitExcludeEntries: string[];
+}
+export declare function buildNexusProjectTemplateLayout(options: Omit<MaterializeNexusProjectTemplateOptions, "excludeFromGit">): NexusProjectTemplateLayout;
+export declare function materializeNexusProjectTemplate(options: MaterializeNexusProjectTemplateOptions): MaterializeNexusProjectTemplateResult;
+export declare function nexusProjectTemplateMigrationNotes(): string[];