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

package/dist/vibeKanbanBoardAdapter.js

@@ -0,0 +1,196 @@
+import { randomUUID } from "node:crypto";
+import { vibeKanbanApiBaseUrl, vibeKanbanPinnedVersion, } from "./vibeKanbanApi.js";
+export class VibeKanbanBoardAdapterError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "VibeKanbanBoardAdapterError";
+    }
+}
+function assertRecord(value, pathName) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new VibeKanbanBoardAdapterError(`${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 VibeKanbanBoardAdapterError(`${pathName}.${key} must be a non-empty string`);
+    }
+    return value;
+}
+function parseApiSuccess(value) {
+    const response = assertRecord(value, "response");
+    if (response.success !== true) {
+        const message = typeof response.message === "string"
+            ? response.message
+            : typeof response.error === "string"
+                ? response.error
+                : "Vibe Kanban request failed";
+        throw new VibeKanbanBoardAdapterError(message);
+    }
+    return response.data;
+}
+function parseOrganization(value) {
+    const record = assertRecord(value, "organization");
+    return {
+        ...record,
+        id: requiredString(record, "id", "organization"),
+    };
+}
+function parseBoard(value) {
+    const record = assertRecord(value, "project");
+    return {
+        ...record,
+        id: requiredString(record, "id", "project"),
+        name: requiredString(record, "name", "project"),
+    };
+}
+async function readJsonResponse(response) {
+    const text = await response.text();
+    if (text.trim().length === 0) {
+        return {};
+    }
+    return JSON.parse(text.replace(/^\uFEFF/, ""));
+}
+async function requestJson(fetchImpl, url, init) {
+    const response = await fetchImpl(url, init);
+    const body = await readJsonResponse(response);
+    if (!response.ok) {
+        const detail = body && typeof body === "object"
+            ? `: ${JSON.stringify(body)}`
+            : "";
+        throw new VibeKanbanBoardAdapterError(`Vibe Kanban request failed with HTTP ${response.status}${detail}`);
+    }
+    return body;
+}
+function remoteRequestHeaders(accessToken) {
+    return {
+        authorization: `Bearer ${accessToken}`,
+        "content-type": "application/json",
+        "x-client-version": vibeKanbanPinnedVersion,
+        "x-client-type": "frontend",
+    };
+}
+function normalizeBaseUrl(value) {
+    return value.replace(/\/+$/, "");
+}
+async function getVibeKanbanInfo(options, fetchImpl) {
+    const url = new URL("/api/info", vibeKanbanApiBaseUrl(options));
+    const raw = await requestJson(fetchImpl, url.toString());
+    const data = assertRecord(parseApiSuccess(raw), "info");
+    return {
+        sharedApiBase: typeof data.shared_api_base === "string" && data.shared_api_base.trim()
+            ? normalizeBaseUrl(data.shared_api_base)
+            : "https://api.vibekanban.com",
+        raw,
+    };
+}
+async function getVibeKanbanAccessToken(options, fetchImpl) {
+    const url = new URL("/api/auth/token", vibeKanbanApiBaseUrl(options));
+    const raw = await requestJson(fetchImpl, url.toString());
+    const data = assertRecord(parseApiSuccess(raw), "auth token");
+    return requiredString(data, "access_token", "auth token");
+}
+async function listOrganizations(sharedApiBase, accessToken, fetchImpl) {
+    const raw = await requestJson(fetchImpl, `${sharedApiBase}/v1/organizations`, {
+        method: "GET",
+        headers: remoteRequestHeaders(accessToken),
+    });
+    const data = assertRecord(raw, "organizations response");
+    const organizations = data.organizations;
+    if (!Array.isArray(organizations)) {
+        throw new VibeKanbanBoardAdapterError("organizations response.organizations must be an array");
+    }
+    return {
+        organizations: organizations.map(parseOrganization),
+        raw,
+    };
+}
+async function listBoards(sharedApiBase, accessToken, organizationId, fetchImpl) {
+    const url = new URL(`${sharedApiBase}/v1/fallback/projects`);
+    url.searchParams.set("organization_id", organizationId);
+    const raw = await requestJson(fetchImpl, url.toString(), {
+        method: "GET",
+        headers: remoteRequestHeaders(accessToken),
+    });
+    const data = assertRecord(raw, "projects response");
+    const projects = data.projects;
+    if (!Array.isArray(projects)) {
+        throw new VibeKanbanBoardAdapterError("projects response.projects must be an array");
+    }
+    return {
+        boards: projects.map(parseBoard),
+        raw,
+    };
+}
+async function createBoard(sharedApiBase, accessToken, organizationId, name, color, uuid, fetchImpl) {
+    const board = {
+        id: uuid(),
+        organization_id: organizationId,
+        name,
+        color,
+    };
+    const raw = await requestJson(fetchImpl, `${sharedApiBase}/v1/projects`, {
+        method: "POST",
+        headers: remoteRequestHeaders(accessToken),
+        body: JSON.stringify(board),
+    });
+    return {
+        board,
+        raw,
+    };
+}
+function selectOrganization(organizations, organizationId) {
+    if (organizationId) {
+        const matched = organizations.find((organization) => organization.id === organizationId);
+        if (!matched) {
+            throw new VibeKanbanBoardAdapterError(`Vibe Kanban organization was not found: ${organizationId}`);
+        }
+        return matched;
+    }
+    const personal = organizations.find((organization) => organization.is_personal === true);
+    const selected = personal ?? organizations[0];
+    if (!selected) {
+        throw new VibeKanbanBoardAdapterError("No Vibe Kanban organizations are available");
+    }
+    return selected;
+}
+export async function ensureVibeKanbanBoard(options) {
+    if (options.name.trim().length === 0) {
+        throw new VibeKanbanBoardAdapterError("name must be non-empty");
+    }
+    const fetchImpl = options.fetch ?? fetch;
+    const info = await getVibeKanbanInfo(options, fetchImpl);
+    const accessToken = await getVibeKanbanAccessToken(options, fetchImpl);
+    const organizations = await listOrganizations(info.sharedApiBase, accessToken, fetchImpl);
+    const organization = selectOrganization(organizations.organizations, options.organizationId);
+    const projects = await listBoards(info.sharedApiBase, accessToken, organization.id, fetchImpl);
+    const existing = projects.boards.find((board) => board.name === options.name);
+    if (existing) {
+        return {
+            boardId: existing.id,
+            board: existing,
+            organization,
+            created: false,
+            raw: {
+                info: info.raw,
+                organizations: organizations.raw,
+                projects: projects.raw,
+            },
+        };
+    }
+    const created = await createBoard(info.sharedApiBase, accessToken, organization.id, options.name, options.color ?? "210 90% 54%", options.uuid ?? randomUUID, fetchImpl);
+    return {
+        boardId: created.board.id,
+        board: created.board,
+        organization,
+        created: true,
+        raw: {
+            info: info.raw,
+            organizations: organizations.raw,
+            projects: projects.raw,
+            create: created.raw,
+        },
+    };
+}

package/dist/vibeKanbanMcpConfig.d.ts

@@ -0,0 +1,36 @@
+import { type VibeKanbanApiOptions } from "./vibeKanbanApi.js";
+export declare const vibeKanbanExecutors: readonly ["CLAUDE_CODE", "AMP", "GEMINI", "CODEX", "OPENCODE", "CURSOR_AGENT", "QWEN_CODE", "COPILOT", "DROID"];
+export type VibeKanbanExecutor = (typeof vibeKanbanExecutors)[number];
+export interface VibeKanbanMcpServerConfig {
+    type?: string;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    headers?: Record<string, string>;
+    [key: string]: unknown;
+}
+export interface VibeKanbanMcpConfig {
+    servers: Record<string, VibeKanbanMcpServerConfig>;
+    serversPath?: string[];
+    configPath?: string;
+}
+export interface VibeKanbanMcpConfigResponse {
+    mcpConfig: VibeKanbanMcpConfig;
+    raw: unknown;
+}
+export declare class VibeKanbanMcpConfigError extends Error {
+    constructor(message: string);
+}
+export declare function normalizeVibeKanbanExecutor(executor: string): VibeKanbanExecutor;
+export declare function validateMcpServerConfig(value: unknown, pathName: string): VibeKanbanMcpServerConfig;
+export declare function validateMcpServers(value: unknown): Record<string, VibeKanbanMcpServerConfig>;
+export declare function normalizeExistingMcpServers(value: unknown): Record<string, VibeKanbanMcpServerConfig>;
+export declare function getVibeKanbanMcpConfig(options: VibeKanbanApiOptions & {
+    executor: string;
+}): Promise<VibeKanbanMcpConfigResponse>;
+export declare function updateVibeKanbanMcpConfig(options: VibeKanbanApiOptions & {
+    executor: string;
+    servers: Record<string, VibeKanbanMcpServerConfig>;
+}): Promise<unknown>;
+export declare function mergeMcpServerConfig(servers: Record<string, VibeKanbanMcpServerConfig>, serverName: string, server: VibeKanbanMcpServerConfig): Record<string, VibeKanbanMcpServerConfig>;

package/dist/vibeKanbanMcpConfig.js

@@ -0,0 +1,191 @@
+import { vibeKanbanApiBaseUrl } from "./vibeKanbanApi.js";
+export const vibeKanbanExecutors = [
+    "CLAUDE_CODE",
+    "AMP",
+    "GEMINI",
+    "CODEX",
+    "OPENCODE",
+    "CURSOR_AGENT",
+    "QWEN_CODE",
+    "COPILOT",
+    "DROID",
+];
+export class VibeKanbanMcpConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "VibeKanbanMcpConfigError";
+    }
+}
+function assertRecord(value, pathName) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new VibeKanbanMcpConfigError(`${pathName} must be an object`);
+    }
+    return value;
+}
+function optionalStringArray(value, pathName) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+        throw new VibeKanbanMcpConfigError(`${pathName} must be an array of strings`);
+    }
+    return value;
+}
+export function normalizeVibeKanbanExecutor(executor) {
+    const normalized = executor.trim().replaceAll("-", "_").toUpperCase();
+    if (normalized === "CURSOR") {
+        return "CURSOR_AGENT";
+    }
+    if (vibeKanbanExecutors.includes(normalized)) {
+        return normalized;
+    }
+    throw new VibeKanbanMcpConfigError(`Unsupported Vibe Kanban executor: ${executor}`);
+}
+export function validateMcpServerConfig(value, pathName) {
+    const record = assertRecord(value, pathName);
+    const commandValue = record.command;
+    const urlValue = record.url;
+    const hasCommand = typeof commandValue === "string" && commandValue.trim().length > 0;
+    const hasUrl = typeof urlValue === "string" && urlValue.trim().length > 0;
+    if (!hasCommand && !hasUrl) {
+        throw new VibeKanbanMcpConfigError(`${pathName}.command or ${pathName}.url must be a non-empty string`);
+    }
+    if (commandValue !== undefined && !hasCommand) {
+        throw new VibeKanbanMcpConfigError(`${pathName}.command must be a non-empty string`);
+    }
+    if (urlValue !== undefined && !hasUrl) {
+        throw new VibeKanbanMcpConfigError(`${pathName}.url must be a non-empty string`);
+    }
+    const argsValue = record.args;
+    if (argsValue !== undefined &&
+        (!Array.isArray(argsValue) || argsValue.some((arg) => typeof arg !== "string"))) {
+        throw new VibeKanbanMcpConfigError(`${pathName}.args must be an array of strings`);
+    }
+    const args = argsValue ?? (hasCommand ? [] : undefined);
+    const envValue = record.env;
+    let env;
+    if (envValue !== undefined) {
+        const envRecord = assertRecord(envValue, `${pathName}.env`);
+        env = {};
+        for (const [key, valueEntry] of Object.entries(envRecord)) {
+            if (typeof valueEntry !== "string") {
+                throw new VibeKanbanMcpConfigError(`${pathName}.env.${key} must be a string`);
+            }
+            env[key] = valueEntry;
+        }
+    }
+    const headersValue = record.headers;
+    let headers;
+    if (headersValue !== undefined) {
+        const headersRecord = assertRecord(headersValue, `${pathName}.headers`);
+        headers = {};
+        for (const [key, valueEntry] of Object.entries(headersRecord)) {
+            if (typeof valueEntry !== "string") {
+                throw new VibeKanbanMcpConfigError(`${pathName}.headers.${key} must be a string`);
+            }
+            headers[key] = valueEntry;
+        }
+    }
+    return {
+        ...record,
+        ...(hasCommand ? { command: commandValue } : {}),
+        ...(args ? { args } : {}),
+        ...(env ? { env } : {}),
+        ...(hasUrl ? { url: urlValue } : {}),
+        ...(headers ? { headers } : {}),
+    };
+}
+export function validateMcpServers(value) {
+    const record = assertRecord(value, "servers");
+    const servers = {};
+    for (const [name, serverConfig] of Object.entries(record)) {
+        if (!name.trim()) {
+            throw new VibeKanbanMcpConfigError("MCP server names must be non-empty");
+        }
+        servers[name] = validateMcpServerConfig(serverConfig, `servers.${name}`);
+    }
+    return servers;
+}
+export function normalizeExistingMcpServers(value) {
+    const record = assertRecord(value, "servers");
+    const servers = {};
+    for (const [name, serverConfig] of Object.entries(record)) {
+        if (!name.trim()) {
+            throw new VibeKanbanMcpConfigError("MCP server names must be non-empty");
+        }
+        const serverRecord = assertRecord(serverConfig, `servers.${name}`);
+        const command = serverRecord.command;
+        const args = serverRecord.args;
+        const hasValidCommand = typeof command === "string" && command.trim().length > 0;
+        const hasMissingArgs = args === undefined;
+        servers[name] =
+            hasValidCommand && hasMissingArgs
+                ? {
+                    ...serverRecord,
+                    args: [],
+                }
+                : serverRecord;
+    }
+    return servers;
+}
+function parseMcpConfigResponse(value) {
+    const response = assertRecord(value, "response");
+    if (response.success !== true) {
+        throw new VibeKanbanMcpConfigError("Vibe Kanban MCP config request failed");
+    }
+    const data = assertRecord(response.data, "response.data");
+    const mcpConfig = assertRecord(data.mcp_config, "response.data.mcp_config");
+    const configPath = typeof data.config_path === "string" ? data.config_path : undefined;
+    return {
+        raw: value,
+        mcpConfig: {
+            servers: normalizeExistingMcpServers(mcpConfig.servers ?? {}),
+            serversPath: optionalStringArray(mcpConfig.servers_path, "response.data.mcp_config.servers_path"),
+            ...(configPath ? { configPath } : {}),
+        },
+    };
+}
+async function readJsonResponse(response) {
+    const text = await response.text();
+    if (text.trim().length === 0) {
+        return {};
+    }
+    return JSON.parse(text.replace(/^\uFEFF/, ""));
+}
+async function requestJson(fetchImpl, url, init) {
+    const response = await fetchImpl(url, init);
+    const body = await readJsonResponse(response);
+    if (!response.ok) {
+        throw new VibeKanbanMcpConfigError(`Vibe Kanban request failed with HTTP ${response.status}`);
+    }
+    return body;
+}
+export async function getVibeKanbanMcpConfig(options) {
+    const executor = normalizeVibeKanbanExecutor(options.executor);
+    const url = new URL("/api/mcp-config", vibeKanbanApiBaseUrl(options));
+    url.searchParams.set("executor", executor);
+    return parseMcpConfigResponse(await requestJson(options.fetch ?? fetch, url.toString()));
+}
+export async function updateVibeKanbanMcpConfig(options) {
+    const executor = normalizeVibeKanbanExecutor(options.executor);
+    const url = new URL("/api/mcp-config", vibeKanbanApiBaseUrl(options));
+    url.searchParams.set("executor", executor);
+    return requestJson(options.fetch ?? fetch, url.toString(), {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+        },
+        body: JSON.stringify({
+            servers: normalizeExistingMcpServers(options.servers),
+        }),
+    });
+}
+export function mergeMcpServerConfig(servers, serverName, server) {
+    if (serverName.trim().length === 0) {
+        throw new VibeKanbanMcpConfigError("serverName must be non-empty");
+    }
+    return normalizeExistingMcpServers({
+        ...servers,
+        [serverName]: validateMcpServerConfig(server, `servers.${serverName}`),
+    });
+}

package/dist/vibeKanbanProjectAdapter.d.ts

@@ -0,0 +1,39 @@
+import { type VibeKanbanApiOptions } from "./vibeKanbanApi.js";
+export interface VibeKanbanProject {
+    id: string;
+    path?: string;
+    name?: string;
+    display_name?: string;
+    setup_script?: string | null;
+    cleanup_script?: string | null;
+    dev_server_script?: string | null;
+    [key: string]: unknown;
+}
+export interface RegisterVibeKanbanProjectOptions extends VibeKanbanApiOptions {
+    projectRoot: string;
+    name: string;
+}
+export interface RegisterVibeKanbanProjectResult {
+    projectId: string;
+    project: VibeKanbanProject;
+    raw: unknown;
+}
+export interface UpdateVibeKanbanProjectOptions extends VibeKanbanApiOptions {
+    projectId: string;
+    setupScript?: string | null;
+}
+export interface UpdateVibeKanbanProjectResult {
+    projectId: string;
+    project: VibeKanbanProject;
+    raw: unknown;
+}
+export interface ListVibeKanbanProjectsResult {
+    projects: VibeKanbanProject[];
+    raw: unknown;
+}
+export declare class VibeKanbanProjectAdapterError extends Error {
+    constructor(message: string);
+}
+export declare function listVibeKanbanProjects(options: VibeKanbanApiOptions): Promise<ListVibeKanbanProjectsResult>;
+export declare function registerVibeKanbanProject(options: RegisterVibeKanbanProjectOptions): Promise<RegisterVibeKanbanProjectResult>;
+export declare function updateVibeKanbanProject(options: UpdateVibeKanbanProjectOptions): Promise<UpdateVibeKanbanProjectResult>;

package/dist/vibeKanbanProjectAdapter.js

@@ -0,0 +1,113 @@
+import { vibeKanbanApiBaseUrl } from "./vibeKanbanApi.js";
+export class VibeKanbanProjectAdapterError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "VibeKanbanProjectAdapterError";
+    }
+}
+function assertRecord(value, pathName) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new VibeKanbanProjectAdapterError(`${pathName} must be an object`);
+    }
+    return value;
+}
+function parseApiSuccess(value) {
+    const response = assertRecord(value, "response");
+    if (response.success !== true) {
+        const message = typeof response.message === "string"
+            ? response.message
+            : typeof response.error === "string"
+                ? response.error
+                : "Vibe Kanban project request failed";
+        throw new VibeKanbanProjectAdapterError(message);
+    }
+    return response.data;
+}
+function parseProject(value) {
+    const record = assertRecord(value, "project");
+    if (typeof record.id !== "string" || record.id.trim().length === 0) {
+        throw new VibeKanbanProjectAdapterError("project.id must be a non-empty string");
+    }
+    return record;
+}
+async function readJsonResponse(response) {
+    const text = await response.text();
+    if (text.trim().length === 0) {
+        return {};
+    }
+    return JSON.parse(text.replace(/^\uFEFF/, ""));
+}
+async function requestJson(fetchImpl, url, init) {
+    const response = await fetchImpl(url, init);
+    const body = await readJsonResponse(response);
+    if (!response.ok) {
+        const detail = body && typeof body === "object"
+            ? `: ${JSON.stringify(body)}`
+            : "";
+        throw new VibeKanbanProjectAdapterError(`Vibe Kanban project request failed with HTTP ${response.status}${detail}`);
+    }
+    return body;
+}
+export async function listVibeKanbanProjects(options) {
+    const url = new URL("/api/repos", vibeKanbanApiBaseUrl(options));
+    const raw = await requestJson(options.fetch ?? fetch, url.toString());
+    const data = parseApiSuccess(raw);
+    if (!Array.isArray(data)) {
+        throw new VibeKanbanProjectAdapterError("response.data must be an array");
+    }
+    return {
+        projects: data.map(parseProject),
+        raw,
+    };
+}
+export async function registerVibeKanbanProject(options) {
+    if (options.projectRoot.trim().length === 0) {
+        throw new VibeKanbanProjectAdapterError("projectRoot must be non-empty");
+    }
+    if (options.name.trim().length === 0) {
+        throw new VibeKanbanProjectAdapterError("name must be non-empty");
+    }
+    const url = new URL("/api/repos", vibeKanbanApiBaseUrl(options));
+    const raw = await requestJson(options.fetch ?? fetch, url.toString(), {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+        },
+        body: JSON.stringify({
+            path: options.projectRoot,
+            display_name: options.name,
+        }),
+    });
+    const project = parseProject(parseApiSuccess(raw));
+    return {
+        projectId: project.id,
+        project,
+        raw,
+    };
+}
+export async function updateVibeKanbanProject(options) {
+    if (options.projectId.trim().length === 0) {
+        throw new VibeKanbanProjectAdapterError("projectId must be non-empty");
+    }
+    const payload = {};
+    if (options.setupScript !== undefined) {
+        payload.setup_script =
+            options.setupScript && options.setupScript.trim().length > 0
+                ? options.setupScript
+                : null;
+    }
+    const url = new URL(`/api/repos/${encodeURIComponent(options.projectId)}`, vibeKanbanApiBaseUrl(options));
+    const raw = await requestJson(options.fetch ?? fetch, url.toString(), {
+        method: "PUT",
+        headers: {
+            "content-type": "application/json",
+        },
+        body: JSON.stringify(payload),
+    });
+    const project = parseProject(parseApiSuccess(raw));
+    return {
+        projectId: project.id,
+        project,
+        raw,
+    };
+}

package/dist/vibeKanbanWorkspaceSetup.d.ts

@@ -0,0 +1 @@
+export declare function buildVibeKanbanWorkspaceSetupScript(managedRoot: string, sourceRoot: string, platform?: NodeJS.Platform): string;

package/dist/vibeKanbanWorkspaceSetup.js

@@ -0,0 +1,96 @@
+import path from "node:path";
+import process from "node:process";
+function powershellSingleQuoted(value) {
+    return `'${value.replaceAll("'", "''")}'`;
+}
+function buildWindowsVibeKanbanWorkspaceSetupScript(managedRoot, sourceRoot) {
+    return [
+        "$ErrorActionPreference = 'Stop'",
+        `$managedRoot = ${powershellSingleQuoted(path.resolve(managedRoot))}`,
+        `$sourceRoot = ${powershellSingleQuoted(path.resolve(sourceRoot))}`,
+        "$workspaceRoot = (Get-Location).Path",
+        "",
+        "function Add-GitInfoExclude([string] $entry) {",
+        "  $excludePath = git rev-parse --git-path info/exclude",
+        "  if (-not (Test-Path -LiteralPath $excludePath)) {",
+        "    New-Item -ItemType File -Path $excludePath -Force | Out-Null",
+        "  }",
+        "  $existing = Get-Content -LiteralPath $excludePath -ErrorAction SilentlyContinue",
+        "  if ($existing -notcontains $entry) {",
+        "    Add-Content -LiteralPath $excludePath -Value $entry",
+        "  }",
+        "}",
+        "",
+        "$agentsSource = Join-Path $managedRoot 'AGENTS.md'",
+        "$agentsTarget = Join-Path $workspaceRoot 'AGENTS.md'",
+        "if ((Test-Path -LiteralPath $agentsSource) -and -not (Test-Path -LiteralPath $agentsTarget)) {",
+        "  Copy-Item -LiteralPath $agentsSource -Destination $agentsTarget -Force",
+        "  Add-GitInfoExclude 'AGENTS.md'",
+        "}",
+        "",
+        "$codexSource = Join-Path $managedRoot '.codex'",
+        "$codexTarget = Join-Path $workspaceRoot '.codex'",
+        "if ((Test-Path -LiteralPath $codexSource) -and -not (Test-Path -LiteralPath (Join-Path $codexTarget 'config.toml'))) {",
+        "  New-Item -ItemType Directory -Path $codexTarget -Force | Out-Null",
+        "  Copy-Item -Path (Join-Path $codexSource '*') -Destination $codexTarget -Recurse -Force",
+        "  Add-GitInfoExclude '.codex/'",
+        "}",
+        "",
+        "$sourceNodeModules = Join-Path $sourceRoot 'node_modules'",
+        "$workspaceNodeModules = Join-Path $workspaceRoot 'node_modules'",
+        "if ((Test-Path -LiteralPath $sourceNodeModules) -and -not (Test-Path -LiteralPath $workspaceNodeModules)) {",
+        "  New-Item -ItemType Junction -Path $workspaceNodeModules -Target $sourceNodeModules | Out-Null",
+        "  Add-GitInfoExclude 'node_modules/'",
+        "} elseif (-not (Test-Path -LiteralPath $sourceNodeModules)) {",
+        "  Write-Host \"Source checkout has no node_modules at $sourceNodeModules; skipping dependency junction.\"",
+        "}",
+        "",
+        "Write-Host 'Vibe workspace setup complete for DevNexus-managed project.'",
+    ].join("\n");
+}
+function shellSingleQuoted(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function buildPosixVibeKanbanWorkspaceSetupScript(managedRoot, sourceRoot) {
+    return [
+        "set -eu",
+        `managed_root=${shellSingleQuoted(path.resolve(managedRoot))}`,
+        `source_root=${shellSingleQuoted(path.resolve(sourceRoot))}`,
+        "workspace_root=$(pwd)",
+        "",
+        "add_git_info_exclude() {",
+        "  entry=$1",
+        "  exclude_path=$(git rev-parse --git-path info/exclude)",
+        "  mkdir -p \"$(dirname \"$exclude_path\")\"",
+        "  touch \"$exclude_path\"",
+        "  if ! grep -Fxq \"$entry\" \"$exclude_path\"; then",
+        "    printf '%s\\n' \"$entry\" >> \"$exclude_path\"",
+        "  fi",
+        "}",
+        "",
+        "if [ -f \"$managed_root/AGENTS.md\" ] && [ ! -e \"$workspace_root/AGENTS.md\" ]; then",
+        "  cp \"$managed_root/AGENTS.md\" \"$workspace_root/AGENTS.md\"",
+        "  add_git_info_exclude 'AGENTS.md'",
+        "fi",
+        "",
+        "if [ -d \"$managed_root/.codex\" ] && [ ! -f \"$workspace_root/.codex/config.toml\" ]; then",
+        "  mkdir -p \"$workspace_root/.codex\"",
+        "  cp -R \"$managed_root/.codex/.\" \"$workspace_root/.codex/\"",
+        "  add_git_info_exclude '.codex/'",
+        "fi",
+        "",
+        "if [ -d \"$source_root/node_modules\" ] && [ ! -e \"$workspace_root/node_modules\" ]; then",
+        "  ln -s \"$source_root/node_modules\" \"$workspace_root/node_modules\"",
+        "  add_git_info_exclude 'node_modules/'",
+        "elif [ ! -d \"$source_root/node_modules\" ]; then",
+        "  printf '%s\\n' \"Source checkout has no node_modules at $source_root/node_modules; skipping dependency link.\"",
+        "fi",
+        "",
+        "printf '%s\\n' 'Vibe workspace setup complete for DevNexus-managed project.'",
+    ].join("\n");
+}
+export function buildVibeKanbanWorkspaceSetupScript(managedRoot, sourceRoot, platform = process.platform) {
+    return platform === "win32"
+        ? buildWindowsVibeKanbanWorkspaceSetupScript(managedRoot, sourceRoot)
+        : buildPosixVibeKanbanWorkspaceSetupScript(managedRoot, sourceRoot);
+}