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

package/dist/nexusExtension.d.ts

@@ -0,0 +1,31 @@
+import type { NexusSkillDefinition } from "./nexusSkills.js";
+export interface NexusProjectScaffoldContext<ProjectConfig = unknown> {
+    homePath: string;
+    projectRoot: string;
+    worktreesRoot: string;
+    projectConfig: ProjectConfig;
+}
+export interface NexusProjectStatusContext<ProjectConfig = unknown> {
+    projectRoot: string;
+    projectConfig: ProjectConfig;
+}
+export interface NexusProjectTrackerLinkContext<ProjectConfig = unknown> {
+    projectRoot: string;
+    projectConfig: ProjectConfig;
+    trackerProjectId: string;
+}
+export interface NexusProjectSkillsContext<ProjectConfig = unknown> {
+    homePath: string;
+    projectRoot: string;
+    worktreesRoot: string;
+    projectConfig: ProjectConfig;
+}
+export type NexusSkillContribution = NexusSkillDefinition;
+export interface NexusExtension<ProjectConfig = unknown, ProjectScaffoldResult = unknown, ProjectStatusResult = unknown, ProjectTrackerLinkResult = unknown> {
+    id: string;
+    name: string;
+    installProjectFiles?(context: NexusProjectScaffoldContext<ProjectConfig>): ProjectScaffoldResult;
+    projectSkills?(context: NexusProjectSkillsContext<ProjectConfig>): NexusSkillContribution[] | undefined;
+    projectStatus?(context: NexusProjectStatusContext<ProjectConfig>): ProjectStatusResult;
+    linkProjectTracker?(context: NexusProjectTrackerLinkContext<ProjectConfig>): ProjectTrackerLinkResult;
+}

package/dist/nexusExtension.js

@@ -0,0 +1 @@
+export {};

package/dist/nexusHomeConfig.d.ts

@@ -0,0 +1,38 @@
+import { type NexusAgentConfig } from "./nexusProjectConfig.js";
+import type { NexusProjectReference } from "./nexusProjectRegistry.js";
+export declare const devNexusHomeConfigFileName = "dev-nexus.home.json";
+export declare const nexusLogsDirectoryName = "logs";
+export declare const nexusGeneratedDirectoryName = "generated";
+export interface NexusHomePathsConfig {
+    projectsRoot: string;
+    workspacesRoot: string;
+}
+export interface NexusHomeConfigBase {
+    version: 1;
+    paths: NexusHomePathsConfig;
+    agent?: NexusAgentConfig;
+    projects: NexusProjectReference[];
+}
+export interface CreateDefaultNexusHomeConfigBaseOptions {
+    projectsRoot?: string;
+    workspacesRoot?: string;
+    agent?: NexusAgentConfig;
+}
+export interface DefaultNexusHomePathOptions {
+    envVarName?: string;
+    directoryName?: string;
+}
+export interface LoadNexusHomeConfigFileOptions {
+    missingMessage?: string | ((configPath: string) => string);
+}
+type NexusHomeConfigValidator<T> = (value: unknown, homePathForDefaults: string) => T;
+export declare function defaultNexusHomePath(options?: DefaultNexusHomePathOptions): string;
+export declare function resolveNexusHome(homePath: string): string;
+export declare function nexusHomeConfigPath(homePath: string): string;
+export declare const devNexusHomeConfigPath: typeof nexusHomeConfigPath;
+export declare function resolveNexusHomePath(homePath: string, value: string | undefined, fallback: string): string;
+export declare function createDefaultNexusHomeConfigBase(homePath: string, options?: CreateDefaultNexusHomeConfigBaseOptions): NexusHomeConfigBase;
+export declare function validateNexusHomeConfigBase(value: unknown, _homePathForDefaults?: string): NexusHomeConfigBase;
+export declare function loadNexusHomeConfigFile<T>(homePath: string, validate: NexusHomeConfigValidator<T>, options?: LoadNexusHomeConfigFileOptions): T;
+export declare function saveNexusHomeConfigFile<T>(homePath: string, config: T, validate: NexusHomeConfigValidator<T>): string;
+export {};

package/dist/nexusHomeConfig.js

@@ -0,0 +1,133 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { NexusConfigError, validateNexusAgentConfig, } from "./nexusProjectConfig.js";
+export const devNexusHomeConfigFileName = "dev-nexus.home.json";
+export const nexusLogsDirectoryName = "logs";
+export const nexusGeneratedDirectoryName = "generated";
+function assertRecord(value, pathName) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new NexusConfigError(`${pathName} must be an object`);
+    }
+    return value;
+}
+function requiredString(record, key, pathName) {
+    const value = record[key];
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new NexusConfigError(`${pathName}.${key} must be a non-empty string`);
+    }
+    return value;
+}
+function optionalString(record, key, pathName) {
+    const value = record[key];
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new NexusConfigError(`${pathName}.${key} must be a non-empty string`);
+    }
+    return value;
+}
+function validateNexusProjectReference(value, index) {
+    const pathName = `projects[${index}]`;
+    const record = assertRecord(value, pathName);
+    const trackerProjectId = optionalString(record, "vibeKanbanProjectId", pathName);
+    const trackerRepoId = optionalString(record, "vibeKanbanRepoId", pathName);
+    return {
+        id: requiredString(record, "id", pathName),
+        name: requiredString(record, "name", pathName),
+        projectRoot: requiredString(record, "projectRoot", pathName),
+        ...(trackerProjectId ? { vibeKanbanProjectId: trackerProjectId } : {}),
+        ...(trackerRepoId ? { vibeKanbanRepoId: trackerRepoId } : {}),
+    };
+}
+function validateNexusProjectReferences(value) {
+    if (!Array.isArray(value)) {
+        throw new NexusConfigError("projects must be an array");
+    }
+    const projects = value.map(validateNexusProjectReference);
+    const projectIds = new Set();
+    for (const project of projects) {
+        if (projectIds.has(project.id)) {
+            throw new NexusConfigError(`Project id is duplicated: ${project.id}`);
+        }
+        projectIds.add(project.id);
+    }
+    return projects;
+}
+export function defaultNexusHomePath(options = {}) {
+    const envVarName = options.envVarName ?? "DEV_NEXUS_HOME";
+    return (process.env[envVarName] ??
+        path.join(os.homedir(), options.directoryName ?? ".dev-nexus"));
+}
+export function resolveNexusHome(homePath) {
+    if (!homePath.trim()) {
+        throw new NexusConfigError("Nexus home path is required");
+    }
+    return path.resolve(homePath);
+}
+export function nexusHomeConfigPath(homePath) {
+    return path.join(resolveNexusHome(homePath), devNexusHomeConfigFileName);
+}
+export const devNexusHomeConfigPath = nexusHomeConfigPath;
+export function resolveNexusHomePath(homePath, value, fallback) {
+    return path.resolve(homePath, value ?? fallback);
+}
+export function createDefaultNexusHomeConfigBase(homePath, options = {}) {
+    const resolvedHomePath = resolveNexusHome(homePath);
+    const config = {
+        version: 1,
+        paths: {
+            projectsRoot: resolveNexusHomePath(resolvedHomePath, options.projectsRoot, "projects"),
+            workspacesRoot: resolveNexusHomePath(resolvedHomePath, options.workspacesRoot, "workspaces"),
+        },
+        projects: [],
+    };
+    if (options.agent) {
+        config.agent = validateNexusAgentConfig(options.agent, "agent");
+    }
+    return validateNexusHomeConfigBase(config, resolvedHomePath);
+}
+export function validateNexusHomeConfigBase(value, _homePathForDefaults) {
+    const record = assertRecord(value, "config");
+    if (record.version !== 1) {
+        throw new NexusConfigError("config.version must be 1");
+    }
+    const paths = assertRecord(record.paths, "paths");
+    const agent = validateNexusAgentConfig(record.agent, "agent");
+    const config = {
+        version: 1,
+        paths: {
+            projectsRoot: requiredString(paths, "projectsRoot", "paths"),
+            workspacesRoot: requiredString(paths, "workspacesRoot", "paths"),
+        },
+        projects: validateNexusProjectReferences(record.projects),
+    };
+    if (agent) {
+        config.agent = agent;
+    }
+    return config;
+}
+function missingHomeConfigMessage(configPath, options) {
+    if (typeof options.missingMessage === "function") {
+        return options.missingMessage(configPath);
+    }
+    return (options.missingMessage ??
+        `DevNexus home is not initialized: ${configPath}`);
+}
+export function loadNexusHomeConfigFile(homePath, validate, options = {}) {
+    const resolvedHomePath = resolveNexusHome(homePath);
+    const configPath = nexusHomeConfigPath(resolvedHomePath);
+    if (!fs.existsSync(configPath)) {
+        throw new NexusConfigError(missingHomeConfigMessage(configPath, options));
+    }
+    return validate(JSON.parse(fs.readFileSync(configPath, "utf8").replace(/^\uFEFF/, "")), resolvedHomePath);
+}
+export function saveNexusHomeConfigFile(homePath, config, validate) {
+    const resolvedHomePath = resolveNexusHome(homePath);
+    const configPath = nexusHomeConfigPath(resolvedHomePath);
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, `${JSON.stringify(validate(config, resolvedHomePath), null, 2)}\n`, "utf8");
+    return configPath;
+}

package/dist/nexusMcpServer.d.ts

@@ -0,0 +1,31 @@
+import type { GitRunner } from "./gitWorktreeService.js";
+export declare const devNexusMcpProtocolVersion = "2024-11-05";
+type JsonRpcId = string | number | null;
+export interface JsonRpcRequest {
+    jsonrpc?: "2.0";
+    id?: JsonRpcId;
+    method: string;
+    params?: unknown;
+}
+export interface McpTool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+export interface DevNexusMcpToolContext {
+    now?: () => Date | string;
+    gitRunner?: GitRunner;
+    currentPath?: string;
+}
+export interface DevNexusMcpToolResult {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+}
+export declare function listDevNexusMcpTools(): McpTool[];
+export declare function callDevNexusMcpTool(name: string, argsValue: unknown, context?: DevNexusMcpToolContext): Promise<DevNexusMcpToolResult>;
+export declare function handleDevNexusMcpJsonRpcMessage(message: JsonRpcRequest): Promise<unknown | undefined>;
+export declare function runDevNexusMcpStdioServer(): Promise<void>;
+export {};