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

package/dist/nexusProjectHomeService.d.ts

@@ -0,0 +1,121 @@
+import type { NexusProjectConfig } from "./nexusProjectConfig.js";
+import { type ProjectGitCommandResult, type ProjectGitRunner } from "./nexusProjectLifecycle.js";
+import { type ConfigureNexusProjectTrackerProvider, type NexusProjectRegistryWithRoot } from "./nexusProjectOperations.js";
+import { type NexusProjectReference, type NexusProjectStatusBase } from "./nexusProjectRegistry.js";
+import type { ScaffoldNexusProjectResult } from "./nexusProjectScaffold.js";
+import type { WorkTrackingConfig } from "./workTrackingTypes.js";
+export interface NexusProjectHomeStore<Registry extends NexusProjectRegistryWithRoot = NexusProjectRegistryWithRoot> {
+    resolveHomePath(homePath: string): string;
+    loadHomeConfig(homePath: string): Registry;
+    saveHomeConfig(homePath: string, registry: Registry): string;
+}
+export interface CreateNexusProjectOptions {
+    homePath: string;
+    homeStore: NexusProjectHomeStore;
+    name: string;
+    root?: string;
+    from?: string;
+    gitInit?: boolean;
+    vibeKanbanProjectId?: string;
+    gitRunner?: ProjectGitRunner;
+}
+export interface ImportNexusProjectOptions {
+    homePath: string;
+    homeStore: NexusProjectHomeStore;
+    root: string;
+    projectRoot?: string;
+    name?: string;
+    vibeKanbanProjectId?: string;
+    gitRunner?: ProjectGitRunner;
+}
+export interface CreateNexusProjectResult {
+    homePath: string;
+    projectRoot: string;
+    projectConfigPath: string;
+    worktreesRoot: string;
+    projectConfig: NexusProjectConfig;
+    reference: NexusProjectReference;
+    scaffold: ScaffoldNexusProjectResult;
+    git: {
+        operation: "clone" | "init";
+        remoteUrl: string | null;
+        defaultBranch: string | null;
+        commands: ProjectGitCommandResult[];
+    };
+}
+export interface ImportNexusProjectResult {
+    homePath: string;
+    projectRoot: string;
+    projectConfigPath: string;
+    worktreesRoot: string;
+    projectConfig: NexusProjectConfig;
+    reference: NexusProjectReference;
+    scaffold: ScaffoldNexusProjectResult;
+    git: {
+        operation: "import";
+        remoteUrl: string | null;
+        defaultBranch: string | null;
+        commands: ProjectGitCommandResult[];
+    };
+}
+export interface ListNexusProjectsOptions {
+    homePath: string;
+    homeStore: NexusProjectHomeStore;
+}
+export interface ListNexusProjectsResult {
+    homePath: string;
+    projects: NexusProjectStatusBase[];
+}
+export interface GetNexusProjectStatusOptions {
+    homePath: string;
+    homeStore: NexusProjectHomeStore;
+    project: string;
+}
+export interface GetNexusProjectStatusResult {
+    homePath: string;
+    project: NexusProjectStatusBase;
+}
+export interface LinkNexusProjectTrackerOptions {
+    homePath: string;
+    homeStore: NexusProjectHomeStore;
+    project: string;
+    trackerProjectId: string;
+}
+export interface LinkNexusProjectTrackerResult {
+    homePath: string;
+    vibeKanbanProjectId: string;
+    vibeKanbanRepoId: string | null;
+    project: NexusProjectStatusBase;
+    projectRoot: string;
+    projectConfigPath: string;
+    projectConfig: NexusProjectConfig;
+}
+export interface ConfigureNexusProjectTrackerOptions {
+    homePath: string;
+    homeStore: NexusProjectHomeStore;
+    project: string;
+    provider: ConfigureNexusProjectTrackerProvider;
+    host?: string;
+    repositoryOwner?: string;
+    repositoryName?: string;
+    repositoryId?: string;
+    projectKey?: string;
+    issueType?: string;
+    storePath?: string;
+}
+export interface ConfigureNexusProjectTrackerResult {
+    homePath: string;
+    project: NexusProjectStatusBase;
+    projectRoot: string;
+    projectConfigPath: string;
+    projectConfig: NexusProjectConfig;
+    reference: NexusProjectReference;
+    workTracking: WorkTrackingConfig;
+}
+export declare function statusForNexusProjectReference(reference: NexusProjectReference): NexusProjectStatusBase;
+export declare function createNexusProject(options: CreateNexusProjectOptions): CreateNexusProjectResult;
+export declare function importNexusProject(options: ImportNexusProjectOptions): ImportNexusProjectResult;
+export declare function listNexusProjects(options: ListNexusProjectsOptions): ListNexusProjectsResult;
+export declare function getNexusProjectStatus(options: GetNexusProjectStatusOptions): GetNexusProjectStatusResult;
+export declare function linkNexusProjectTracker(options: LinkNexusProjectTrackerOptions): LinkNexusProjectTrackerResult;
+export declare function configureNexusProjectTracker(options: ConfigureNexusProjectTrackerOptions): ConfigureNexusProjectTrackerResult;

package/dist/nexusProjectHomeService.js

@@ -0,0 +1,171 @@
+import path from "node:path";
+import { assertNonEmptyString, NexusProjectError, } from "./nexusProjectLifecycle.js";
+import { configureNexusProjectTrackerInRegistry, createNexusProjectInRegistry, importNexusProjectInRegistry, linkNexusProjectTrackerInRegistry, } from "./nexusProjectOperations.js";
+import { buildNexusProjectStatus, buildNexusProjectStatusForPath, findNexusProjectReferenceById, findNexusProjectReferenceByPath, projectRootFromInput, } from "./nexusProjectRegistry.js";
+function loadProjectHome(options) {
+    const homePath = options.homeStore.resolveHomePath(options.homePath);
+    return {
+        homePath,
+        registry: options.homeStore.loadHomeConfig(homePath),
+    };
+}
+function saveProjectHome(homeStore, homePath, registry) {
+    homeStore.saveHomeConfig(homePath, registry);
+}
+export function statusForNexusProjectReference(reference) {
+    return buildNexusProjectStatus(reference);
+}
+function statusForNexusProjectPath(projectRoot) {
+    const baseStatus = buildNexusProjectStatusForPath(projectRoot);
+    return statusForNexusProjectReference({
+        id: baseStatus.id,
+        name: baseStatus.name,
+        projectRoot: baseStatus.projectRoot,
+        ...(baseStatus.vibeKanbanProjectId
+            ? { vibeKanbanProjectId: baseStatus.vibeKanbanProjectId }
+            : {}),
+        ...(baseStatus.vibeKanbanRepoId
+            ? { vibeKanbanRepoId: baseStatus.vibeKanbanRepoId }
+            : {}),
+    });
+}
+export function createNexusProject(options) {
+    const { homePath, registry } = loadProjectHome(options);
+    const result = createNexusProjectInRegistry({
+        homePath,
+        registry,
+        name: options.name,
+        ...(options.root !== undefined ? { root: options.root } : {}),
+        ...(options.from !== undefined ? { from: options.from } : {}),
+        ...(options.gitInit !== undefined ? { gitInit: options.gitInit } : {}),
+        ...(options.vibeKanbanProjectId !== undefined
+            ? { vibeKanbanProjectId: options.vibeKanbanProjectId }
+            : {}),
+        ...(options.gitRunner ? { gitRunner: options.gitRunner } : {}),
+    });
+    saveProjectHome(options.homeStore, homePath, registry);
+    return {
+        homePath,
+        projectRoot: result.projectRoot,
+        projectConfigPath: result.projectConfigPath,
+        worktreesRoot: result.worktreesRoot,
+        projectConfig: result.projectConfig,
+        reference: result.reference,
+        scaffold: result.scaffold,
+        git: result.git,
+    };
+}
+export function importNexusProject(options) {
+    const { homePath, registry } = loadProjectHome(options);
+    const result = importNexusProjectInRegistry({
+        homePath,
+        registry,
+        root: options.root,
+        ...(options.projectRoot !== undefined
+            ? { projectRoot: options.projectRoot }
+            : {}),
+        ...(options.name !== undefined ? { name: options.name } : {}),
+        ...(options.vibeKanbanProjectId !== undefined
+            ? { vibeKanbanProjectId: options.vibeKanbanProjectId }
+            : {}),
+        ...(options.gitRunner ? { gitRunner: options.gitRunner } : {}),
+    });
+    saveProjectHome(options.homeStore, homePath, registry);
+    return {
+        homePath,
+        projectRoot: result.projectRoot,
+        projectConfigPath: result.projectConfigPath,
+        worktreesRoot: result.worktreesRoot,
+        projectConfig: result.projectConfig,
+        reference: result.reference,
+        scaffold: result.scaffold,
+        git: result.git,
+    };
+}
+export function listNexusProjects(options) {
+    const { homePath, registry } = loadProjectHome(options);
+    return {
+        homePath,
+        projects: registry.projects.map(statusForNexusProjectReference),
+    };
+}
+export function getNexusProjectStatus(options) {
+    assertNonEmptyString(options.project, "project");
+    const { homePath, registry } = loadProjectHome(options);
+    const projectSelector = options.project.trim();
+    const reference = findNexusProjectReferenceById(registry, projectSelector) ??
+        findNexusProjectReferenceByPath(registry, projectSelector);
+    let project;
+    if (reference) {
+        project = statusForNexusProjectReference(reference);
+    }
+    else {
+        const projectRoot = projectRootFromInput(projectSelector);
+        try {
+            project = statusForNexusProjectPath(projectRoot);
+        }
+        catch (error) {
+            if (error instanceof NexusProjectError) {
+                throw new NexusProjectError(`No registered project matched "${projectSelector}". ` +
+                    `Path fallback checked "${path.resolve(projectRoot)}" and failed: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+    return {
+        homePath,
+        project,
+    };
+}
+export function linkNexusProjectTracker(options) {
+    assertNonEmptyString(options.project, "project");
+    const { homePath, registry } = loadProjectHome(options);
+    const result = linkNexusProjectTrackerInRegistry({
+        registry,
+        project: options.project,
+        trackerProjectId: options.trackerProjectId,
+    });
+    saveProjectHome(options.homeStore, homePath, registry);
+    return {
+        homePath,
+        vibeKanbanProjectId: result.vibeKanbanProjectId,
+        vibeKanbanRepoId: result.vibeKanbanRepoId,
+        project: statusForNexusProjectReference(result.reference),
+        projectRoot: result.projectRoot,
+        projectConfigPath: result.projectConfigPath,
+        projectConfig: result.projectConfig,
+    };
+}
+export function configureNexusProjectTracker(options) {
+    assertNonEmptyString(options.project, "project");
+    assertNonEmptyString(options.provider, "provider");
+    const { homePath, registry } = loadProjectHome(options);
+    const result = configureNexusProjectTrackerInRegistry({
+        registry,
+        project: options.project,
+        provider: options.provider,
+        ...(options.host !== undefined ? { host: options.host } : {}),
+        ...(options.repositoryOwner !== undefined
+            ? { repositoryOwner: options.repositoryOwner }
+            : {}),
+        ...(options.repositoryName !== undefined
+            ? { repositoryName: options.repositoryName }
+            : {}),
+        ...(options.repositoryId !== undefined
+            ? { repositoryId: options.repositoryId }
+            : {}),
+        ...(options.projectKey !== undefined ? { projectKey: options.projectKey } : {}),
+        ...(options.issueType !== undefined ? { issueType: options.issueType } : {}),
+        ...(options.storePath !== undefined ? { storePath: options.storePath } : {}),
+    });
+    saveProjectHome(options.homeStore, homePath, registry);
+    return {
+        homePath,
+        project: statusForNexusProjectReference(result.reference),
+        projectRoot: result.projectRoot,
+        projectConfigPath: result.projectConfigPath,
+        projectConfig: result.projectConfig,
+        reference: result.reference,
+        workTracking: result.workTracking,
+    };
+}

package/dist/nexusProjectLifecycle.d.ts

@@ -0,0 +1,62 @@
+import { type NexusProjectComponentConfig, type NexusProjectConfig } from "./nexusProjectConfig.js";
+import type { TrackerCapabilities, WorkTrackerCapabilityReport } from "./workTrackingTypes.js";
+export interface ProjectGitCommandResult {
+    args: string[];
+    stdout: string;
+    stderr: string;
+    exitCode: number | null;
+}
+export type ProjectGitRunner = (args: readonly string[], cwd?: string) => ProjectGitCommandResult;
+export interface NexusProjectRegistryEntry {
+    id: string;
+    name?: string;
+    projectRoot: string;
+}
+export interface NexusProjectRegistryConfig {
+    paths: {
+        projectsRoot: string;
+    };
+    projects: NexusProjectRegistryEntry[];
+}
+export declare class NexusProjectError extends Error {
+    constructor(message: string);
+}
+export declare function assertNonEmptyString(value: string, name: string): void;
+export declare function optionalNonEmptyString(value: string | undefined, name: string): string | undefined;
+export declare function slugify(value: string): string;
+export declare function safeProjectDirectoryName(value: string): string;
+export declare function directoryExistsAndIsNonEmpty(directoryPath: string): boolean;
+export declare function assertFileDoesNotExist(filePath: string): void;
+export declare const defaultSourceCheckoutDirectoryName = "git";
+export interface ResolvedNexusProjectComponent {
+    id: string;
+    name: string;
+    kind: NexusProjectComponentConfig["kind"];
+    role: NexusProjectComponentConfig["role"];
+    remoteUrl: string | null;
+    defaultBranch: string | null;
+    sourceRoot: string;
+    sourceRootExists: boolean;
+    worktreesRoot: string;
+    worktreesRootExists: boolean;
+    workTracking: NexusProjectComponentConfig["workTracking"] | null;
+    workTrackingCapabilities: TrackerCapabilities | null;
+    workTrackingCapabilityReport: WorkTrackerCapabilityReport | null;
+    verification: NexusProjectComponentConfig["verification"] | null;
+    publication: NexusProjectComponentConfig["publication"] | null;
+    relationships: NexusProjectComponentConfig["relationships"];
+}
+export declare function resolveProjectSourceRoot(projectRoot: string, projectConfig: NexusProjectConfig): string;
+export declare function resolvePrimaryProjectComponent(projectRoot: string, projectConfig: NexusProjectConfig): ResolvedNexusProjectComponent;
+export declare function resolveProjectComponents(projectRoot: string, projectConfig: NexusProjectConfig): ResolvedNexusProjectComponent[];
+export declare function resolveProjectComponent(projectRoot: string, projectConfig: NexusProjectConfig, component: NexusProjectComponentConfig): ResolvedNexusProjectComponent;
+export declare function defaultProjectGitRunner(args: readonly string[], cwd?: string): ProjectGitCommandResult;
+export declare function runProjectGitCommand(gitRunner: ProjectGitRunner, commands: ProjectGitCommandResult[], args: readonly string[], cwd?: string): ProjectGitCommandResult;
+export declare function detectDefaultBranch(gitRunner: ProjectGitRunner, commands: ProjectGitCommandResult[], projectRoot: string): string | null;
+export declare function assertGitRepository(gitRunner: ProjectGitRunner, commands: ProjectGitCommandResult[], projectRoot: string): void;
+export declare function detectOriginUrl(gitRunner: ProjectGitRunner, commands: ProjectGitCommandResult[], projectRoot: string): string | null;
+export declare function samePath(left: string, right: string): boolean;
+export declare function ensureUniqueProject(config: Pick<NexusProjectRegistryConfig, "projects">, projectId: string, projectRoot: string): void;
+export declare function pathForProjectConfig(projectRoot: string, targetPath: string): string;
+export declare function defaultImportedProjectRoot(homeConfig: NexusProjectRegistryConfig, projectName: string, sourceRoot: string): string;
+export declare function loadProjectConfigIfExists(projectRoot: string): NexusProjectConfig | undefined;

package/dist/nexusProjectLifecycle.js

@@ -0,0 +1,205 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { loadProjectConfig, projectConfigPath, projectWorktreesRootPath, validateProjectConfig, } from "./nexusProjectConfig.js";
+import { workTrackerCapabilityReportForConfig, workTrackerCapabilitiesForConfig, } from "./workTrackingProviderService.js";
+export class NexusProjectError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "NexusProjectError";
+    }
+}
+export function assertNonEmptyString(value, name) {
+    if (value.trim().length === 0) {
+        throw new NexusProjectError(`${name} must be a non-empty string`);
+    }
+}
+export function optionalNonEmptyString(value, name) {
+    if (value === undefined) {
+        return undefined;
+    }
+    assertNonEmptyString(value, name);
+    return value.trim();
+}
+export function slugify(value) {
+    const withWordBreaks = value
+        .trim()
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2");
+    const slug = withWordBreaks
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    if (!slug) {
+        throw new NexusProjectError("Project name must contain at least one filesystem-safe character");
+    }
+    return slug;
+}
+export function safeProjectDirectoryName(value) {
+    const sanitized = value
+        .trim()
+        .replace(/[<>:"/\\|?*\u0000-\u001F]+/g, "-")
+        .replace(/\s+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return sanitized || slugify(value);
+}
+export function directoryExistsAndIsNonEmpty(directoryPath) {
+    if (!fs.existsSync(directoryPath)) {
+        return false;
+    }
+    const stat = fs.statSync(directoryPath);
+    if (!stat.isDirectory()) {
+        throw new NexusProjectError(`Project root exists and is not a directory: ${directoryPath}`);
+    }
+    return fs.readdirSync(directoryPath).length > 0;
+}
+export function assertFileDoesNotExist(filePath) {
+    if (fs.existsSync(filePath)) {
+        throw new NexusProjectError(`Refusing to overwrite existing file: ${filePath}`);
+    }
+}
+export const defaultSourceCheckoutDirectoryName = "git";
+export function resolveProjectSourceRoot(projectRoot, projectConfig) {
+    return resolvePrimaryProjectComponent(projectRoot, projectConfig).sourceRoot;
+}
+export function resolvePrimaryProjectComponent(projectRoot, projectConfig) {
+    const components = resolveProjectComponents(projectRoot, projectConfig);
+    const primary = components.find((component) => component.role === "primary") ?? components[0];
+    if (!primary) {
+        throw new NexusProjectError("DevNexus project has no components");
+    }
+    return primary;
+}
+export function resolveProjectComponents(projectRoot, projectConfig) {
+    const normalizedConfig = validateProjectConfig(projectConfig);
+    return normalizedConfig.components.map((component) => resolveProjectComponent(projectRoot, normalizedConfig, component));
+}
+export function resolveProjectComponent(projectRoot, projectConfig, component) {
+    const sourceRoot = resolveProjectPath(projectRoot, component.sourceRoot ?? `components/${component.id}`);
+    const worktreesRoot = resolveComponentWorktreesRoot(projectRoot, projectConfig, component);
+    return {
+        id: component.id,
+        name: component.name,
+        kind: component.kind,
+        role: component.role,
+        remoteUrl: component.remoteUrl,
+        defaultBranch: component.defaultBranch,
+        sourceRoot,
+        sourceRootExists: directoryExists(sourceRoot),
+        worktreesRoot,
+        worktreesRootExists: directoryExists(worktreesRoot),
+        workTracking: component.workTracking ?? null,
+        workTrackingCapabilities: component.workTracking
+            ? workTrackerCapabilitiesForConfig(component.workTracking)
+            : null,
+        workTrackingCapabilityReport: component.workTracking
+            ? workTrackerCapabilityReportForConfig(component.workTracking)
+            : null,
+        verification: component.verification ?? null,
+        publication: component.publication ?? null,
+        relationships: component.relationships,
+    };
+}
+function resolveComponentWorktreesRoot(projectRoot, projectConfig, component) {
+    if (component.worktreesRoot) {
+        return resolveProjectPath(projectRoot, component.worktreesRoot);
+    }
+    return path.join(projectWorktreesRootPath(projectRoot, projectConfig), component.id);
+}
+function resolveProjectPath(projectRoot, value) {
+    return path.isAbsolute(value)
+        ? path.resolve(value)
+        : path.resolve(projectRoot, value);
+}
+function directoryExists(directoryPath) {
+    return fs.existsSync(directoryPath) && fs.statSync(directoryPath).isDirectory();
+}
+export function defaultProjectGitRunner(args, cwd) {
+    const result = spawnSync("git", [...args], {
+        cwd,
+        encoding: "utf8",
+        shell: false,
+        windowsHide: true,
+    });
+    if (result.error) {
+        throw new NexusProjectError(`Failed to run git ${args.join(" ")}: ${result.error.message}`);
+    }
+    const commandResult = {
+        args: [...args],
+        stdout: result.stdout ?? "",
+        stderr: result.stderr ?? "",
+        exitCode: result.status,
+    };
+    if (result.status !== 0) {
+        throw new NexusProjectError(`git ${args.join(" ")} failed with exit code ${result.status}: ${commandResult.stderr.trim() || commandResult.stdout.trim()}`);
+    }
+    return commandResult;
+}
+export function runProjectGitCommand(gitRunner, commands, args, cwd) {
+    const result = gitRunner(args, cwd);
+    commands.push(result);
+    if (result.exitCode !== 0) {
+        throw new NexusProjectError(`git ${args.join(" ")} failed with exit code ${result.exitCode}: ${result.stderr.trim() || result.stdout.trim()}`);
+    }
+    return result;
+}
+function tryGitCommand(gitRunner, commands, args, cwd) {
+    try {
+        return runProjectGitCommand(gitRunner, commands, args, cwd);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function detectDefaultBranch(gitRunner, commands, projectRoot) {
+    const result = tryGitCommand(gitRunner, commands, ["-C", projectRoot, "symbolic-ref", "--short", "HEAD"]);
+    const branch = result?.stdout.trim();
+    return branch && branch !== "HEAD" ? branch : null;
+}
+export function assertGitRepository(gitRunner, commands, projectRoot) {
+    const result = runProjectGitCommand(gitRunner, commands, ["-C", projectRoot, "rev-parse", "--is-inside-work-tree"]);
+    if (result.stdout.trim() !== "true") {
+        throw new NexusProjectError(`Path is not inside a Git work tree: ${projectRoot}`);
+    }
+}
+export function detectOriginUrl(gitRunner, commands, projectRoot) {
+    const result = tryGitCommand(gitRunner, commands, ["-C", projectRoot, "config", "--get", "remote.origin.url"]);
+    const remoteUrl = result?.stdout.trim();
+    return remoteUrl || null;
+}
+function normalizedPathForCompare(filePath) {
+    const resolved = path.resolve(filePath);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+export function samePath(left, right) {
+    return normalizedPathForCompare(left) === normalizedPathForCompare(right);
+}
+export function ensureUniqueProject(config, projectId, projectRoot) {
+    const duplicate = config.projects.find((project) => project.id === projectId || samePath(project.projectRoot, projectRoot));
+    if (duplicate) {
+        throw new NexusProjectError(`Project is already registered: ${duplicate.id}`);
+    }
+}
+export function pathForProjectConfig(projectRoot, targetPath) {
+    const relative = path.relative(projectRoot, targetPath);
+    if (relative &&
+        !relative.startsWith("..") &&
+        !path.isAbsolute(relative)) {
+        return relative;
+    }
+    return path.resolve(targetPath);
+}
+export function defaultImportedProjectRoot(homeConfig, projectName, sourceRoot) {
+    const directoryName = safeProjectDirectoryName(projectName);
+    const candidate = path.join(homeConfig.paths.projectsRoot, directoryName);
+    return samePath(candidate, sourceRoot)
+        ? path.join(homeConfig.paths.projectsRoot, `${directoryName}-DevNexus`)
+        : candidate;
+}
+export function loadProjectConfigIfExists(projectRoot) {
+    if (!fs.existsSync(projectConfigPath(projectRoot))) {
+        return undefined;
+    }
+    return loadProjectConfig(projectRoot);
+}

package/dist/nexusProjectOperations.d.ts

@@ -0,0 +1,101 @@
+import type { NexusExtension } from "./nexusExtension.js";
+import { type NexusProjectConfig, type NexusProjectExtensionsConfig } from "./nexusProjectConfig.js";
+import { type ProjectGitCommandResult, type ProjectGitRunner } from "./nexusProjectLifecycle.js";
+import { type NexusProjectReference, type NexusProjectRegistry } from "./nexusProjectRegistry.js";
+import { type ScaffoldNexusProjectResult } from "./nexusProjectScaffold.js";
+import type { WorkTrackingConfig } from "./workTrackingTypes.js";
+export interface NexusProjectRegistryWithRoot extends NexusProjectRegistry {
+    paths: {
+        projectsRoot: string;
+    };
+}
+export interface CreateNexusProjectInRegistryOptions {
+    homePath: string;
+    registry: NexusProjectRegistryWithRoot;
+    name: string;
+    root?: string;
+    from?: string;
+    gitInit?: boolean;
+    vibeKanbanProjectId?: string;
+    gitRunner?: ProjectGitRunner;
+    extensions?: NexusProjectExtensionsConfig;
+    scaffoldExtensions?: NexusExtension<NexusProjectConfig>[];
+}
+export interface ImportNexusProjectInRegistryOptions {
+    homePath: string;
+    registry: NexusProjectRegistryWithRoot;
+    root: string;
+    projectRoot?: string;
+    name?: string;
+    vibeKanbanProjectId?: string;
+    gitRunner?: ProjectGitRunner;
+    extensions?: NexusProjectExtensionsConfig;
+    scaffoldExtensions?: NexusExtension<NexusProjectConfig>[];
+}
+export interface CreateNexusProjectInRegistryResult {
+    projectRoot: string;
+    projectConfigPath: string;
+    worktreesRoot: string;
+    projectConfig: NexusProjectConfig;
+    reference: NexusProjectReference;
+    scaffold: ScaffoldNexusProjectResult;
+    git: {
+        operation: "clone" | "init";
+        remoteUrl: string | null;
+        defaultBranch: string | null;
+        commands: ProjectGitCommandResult[];
+    };
+}
+export interface ImportNexusProjectInRegistryResult {
+    projectRoot: string;
+    projectConfigPath: string;
+    worktreesRoot: string;
+    projectConfig: NexusProjectConfig;
+    reference: NexusProjectReference;
+    scaffold: ScaffoldNexusProjectResult;
+    git: {
+        operation: "import";
+        remoteUrl: string | null;
+        defaultBranch: string | null;
+        commands: ProjectGitCommandResult[];
+    };
+}
+export type ConfigureNexusProjectTrackerProvider = "local" | "github" | "gitlab" | "jira";
+export interface ConfigureNexusProjectTrackerInRegistryOptions {
+    registry: NexusProjectRegistry;
+    project: string;
+    provider: ConfigureNexusProjectTrackerProvider;
+    host?: string;
+    repositoryOwner?: string;
+    repositoryName?: string;
+    repositoryId?: string;
+    projectKey?: string;
+    issueType?: string;
+    storePath?: string;
+}
+export interface ConfigureNexusProjectTrackerInRegistryResult {
+    projectRoot: string;
+    projectConfigPath: string;
+    projectConfig: NexusProjectConfig;
+    reference: NexusProjectReference;
+    workTracking: WorkTrackingConfig;
+}
+export interface LinkNexusProjectTrackerInRegistryOptions {
+    registry: NexusProjectRegistry;
+    project: string;
+    trackerProjectId: string;
+}
+export interface LinkNexusProjectTrackerInRegistryResult {
+    projectRoot: string;
+    projectConfigPath: string;
+    projectConfig: NexusProjectConfig;
+    reference: NexusProjectReference;
+    vibeKanbanProjectId: string;
+    vibeKanbanRepoId: string | null;
+}
+export declare function buildProjectConfig(name: string, projectId: string, from: string | undefined, defaultBranch: string | null, vibeKanbanProjectId?: string | null, sourceRoot?: string | null, forceGit?: boolean, extensions?: NexusProjectExtensionsConfig): NexusProjectConfig;
+export declare function buildConfiguredWorkTracking(options: ConfigureNexusProjectTrackerInRegistryOptions): WorkTrackingConfig;
+export declare function createNexusProjectInRegistry(options: CreateNexusProjectInRegistryOptions): CreateNexusProjectInRegistryResult;
+export declare function importNexusProjectInRegistry(options: ImportNexusProjectInRegistryOptions): ImportNexusProjectInRegistryResult;
+export declare function configureNexusProjectTrackerInRegistry(options: ConfigureNexusProjectTrackerInRegistryOptions): ConfigureNexusProjectTrackerInRegistryResult;
+export declare function linkNexusProjectTrackerInRegistry(options: LinkNexusProjectTrackerInRegistryOptions): LinkNexusProjectTrackerInRegistryResult;