@yinuo-ngm/mcp-server 0.1.2 → 0.1.3

package/lib/workflow/frontend-task.service.d.ts

@@ -0,0 +1,57 @@
+import type { ResolvedProjectRoot } from "../filesystem/project-files";
+import type { FrontendTask, WorkflowChecks } from "./frontend-task.schema";
+import type { FrontendWorkflowStatus } from "./workflow-status";
+export declare function createTaskId(title: string): string;
+export declare function taskDir(projectRoot: string, taskId: string): string;
+export declare function taskFile(projectRoot: string, taskId: string, fileName: string): string;
+export declare function pendingWorkflowChecks(): WorkflowChecks;
+export declare function readFrontendTask(project: ResolvedProjectRoot, taskId: string): Promise<FrontendTask>;
+export declare function writeFrontendTask(project: ResolvedProjectRoot, task: FrontendTask): Promise<string>;
+export declare function createFrontendTask(project: ResolvedProjectRoot, input: {
+    taskId?: string;
+    title: string;
+    description?: string;
+}): Promise<{
+    status: "executed";
+    task: FrontendTask;
+    changedFiles: string[];
+} | {
+    status: "blocked";
+    taskId: string;
+    reason: string;
+}>;
+export declare function updateTaskStatus(project: ResolvedProjectRoot, taskId: string, status: FrontendWorkflowStatus): Promise<FrontendTask>;
+export declare function updateFrontendTask(project: ResolvedProjectRoot, taskId: string, patch: Partial<Omit<FrontendTask, "taskId" | "createdAt">>): Promise<FrontendTask>;
+export declare function writeTaskMarkdown(project: ResolvedProjectRoot, taskId: string, fileName: string, content: string, nextStatus: FrontendWorkflowStatus): Promise<{
+    task: {
+        status: "failed" | "draft" | "context-ready" | "plan-ready" | "patch-ready" | "applied" | "verified" | "review-ready" | "delivered";
+        projectRoot: string;
+        changedFiles: string[];
+        taskId: string;
+        description: string;
+        createdAt: string;
+        updatedAt: string;
+        title: string;
+        designContextPath: string | null;
+        checks: {
+            standard: "warning" | "passed" | "failed" | "blocked" | "pending";
+            review: "warning" | "passed" | "failed" | "blocked" | "pending";
+            test: "warning" | "passed" | "failed" | "blocked" | "pending";
+            build: "warning" | "passed" | "failed" | "blocked" | "pending";
+        };
+        projectId?: string | undefined;
+    };
+    changedFiles: string[];
+}>;
+export declare function devPlanMarkdown(input: {
+    taskId: string;
+    title: string;
+    context?: string;
+    acceptance?: string[];
+}): string;
+export declare function deliveryReportMarkdown(input: {
+    taskId: string;
+    summary: string;
+    verification?: string[];
+    risks?: string[];
+}): string;

package/lib/workflow/frontend-task.service.js

@@ -0,0 +1,195 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskId = createTaskId;
+exports.taskDir = taskDir;
+exports.taskFile = taskFile;
+exports.pendingWorkflowChecks = pendingWorkflowChecks;
+exports.readFrontendTask = readFrontendTask;
+exports.writeFrontendTask = writeFrontendTask;
+exports.createFrontendTask = createFrontendTask;
+exports.updateTaskStatus = updateTaskStatus;
+exports.updateFrontendTask = updateFrontendTask;
+exports.writeTaskMarkdown = writeTaskMarkdown;
+exports.devPlanMarkdown = devPlanMarkdown;
+exports.deliveryReportMarkdown = deliveryReportMarkdown;
+const fs = __importStar(require("fs/promises"));
+const project_files_1 = require("../filesystem/project-files");
+const frontend_task_schema_1 = require("./frontend-task.schema");
+const workflow_transition_1 = require("./workflow-transition");
+function timestampSlug(date = new Date()) {
+    const pad = (value) => String(value).padStart(2, "0");
+    return [
+        date.getFullYear(),
+        pad(date.getMonth() + 1),
+        pad(date.getDate()),
+        pad(date.getHours()),
+        pad(date.getMinutes()),
+        pad(date.getSeconds()),
+    ].join("");
+}
+function slugify(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 32) || "task";
+}
+function createTaskId(title) {
+    return `fe-${timestampSlug()}-${slugify(title)}`;
+}
+function taskDir(projectRoot, taskId) {
+    (0, project_files_1.validateSafeId)("taskId", taskId);
+    return (0, project_files_1.resolveNgManagerPath)(projectRoot, "frontend-tasks", taskId);
+}
+function taskFile(projectRoot, taskId, fileName) {
+    (0, project_files_1.validateSafeId)("taskId", taskId);
+    (0, project_files_1.validateSafeId)("fileName", fileName.replace(/\.(json|md)$/, ""));
+    return (0, project_files_1.resolveNgManagerPath)(projectRoot, "frontend-tasks", taskId, fileName);
+}
+function pendingWorkflowChecks() {
+    return {
+        standard: "pending",
+        test: "pending",
+        review: "pending",
+        build: "pending",
+    };
+}
+async function readFrontendTask(project, taskId) {
+    const raw = await fs.readFile(taskFile(project.projectRoot, taskId, "task.json"), "utf-8");
+    return frontend_task_schema_1.frontendTaskSchema.parse(JSON.parse(raw));
+}
+async function writeFrontendTask(project, task) {
+    const filePath = taskFile(project.projectRoot, task.taskId, "task.json");
+    await (0, project_files_1.writeJsonFile)(filePath, task);
+    return (0, project_files_1.projectRelativePath)(project.projectRoot, filePath);
+}
+async function createFrontendTask(project, input) {
+    const now = new Date().toISOString();
+    const task = {
+        taskId: input.taskId || createTaskId(input.title),
+        status: "draft",
+        projectId: project.projectId,
+        projectRoot: project.projectRoot,
+        title: input.title,
+        description: input.description ?? "",
+        createdAt: now,
+        updatedAt: now,
+        designContextPath: null,
+        changedFiles: [],
+        checks: pendingWorkflowChecks(),
+    };
+    (0, project_files_1.validateSafeId)("taskId", task.taskId);
+    const dir = taskDir(project.projectRoot, task.taskId);
+    try {
+        await fs.access(taskFile(project.projectRoot, task.taskId, "task.json"));
+        return {
+            status: "blocked",
+            taskId: task.taskId,
+            reason: "frontend task already exists",
+        };
+    }
+    catch {
+    }
+    await fs.mkdir(dir, { recursive: true });
+    const changedFiles = [await writeFrontendTask(project, task)];
+    return { status: "executed", task, changedFiles };
+}
+async function updateTaskStatus(project, taskId, status) {
+    const task = await readFrontendTask(project, taskId);
+    (0, workflow_transition_1.assertWorkflowTransition)(task.status, status);
+    const updated = { ...task, status, updatedAt: new Date().toISOString() };
+    await writeFrontendTask(project, updated);
+    return updated;
+}
+async function updateFrontendTask(project, taskId, patch) {
+    const task = await readFrontendTask(project, taskId);
+    if (patch.status) {
+        (0, workflow_transition_1.assertWorkflowTransition)(task.status, patch.status);
+    }
+    const updated = frontend_task_schema_1.frontendTaskSchema.parse({
+        ...task,
+        ...patch,
+        taskId: task.taskId,
+        createdAt: task.createdAt,
+        updatedAt: new Date().toISOString(),
+    });
+    await writeFrontendTask(project, updated);
+    return updated;
+}
+async function writeTaskMarkdown(project, taskId, fileName, content, nextStatus) {
+    const current = await readFrontendTask(project, taskId);
+    (0, workflow_transition_1.assertWorkflowTransition)(current.status, nextStatus);
+    const filePath = taskFile(project.projectRoot, taskId, fileName);
+    await (0, project_files_1.writeTextFile)(filePath, content);
+    const task = await updateTaskStatus(project, taskId, nextStatus);
+    return {
+        task,
+        changedFiles: [
+            (0, project_files_1.projectRelativePath)(project.projectRoot, filePath),
+            (0, project_files_1.projectRelativePath)(project.projectRoot, taskFile(project.projectRoot, taskId, "task.json")),
+        ],
+    };
+}
+function devPlanMarkdown(input) {
+    const lines = [
+        `# Dev Plan ${input.taskId}`,
+        "",
+        `## Title`,
+        input.title,
+        "",
+        "## Context",
+        input.context || "No design context provided.",
+        "",
+        "## Implementation",
+        "- Inspect related Angular routes, services, stores, and API clients.",
+        "- Make the smallest maintainable change that satisfies the task.",
+        "- Keep write/execute operations previewable and auditable when adding MCP behavior.",
+        "",
+        "## Acceptance",
+        ...(input.acceptance?.length ? input.acceptance.map((item) => `- ${item}`) : ["- Relevant build or package tests pass.", "- Review checklist has no unresolved high-risk item."]),
+    ];
+    return lines.join("\n");
+}
+function deliveryReportMarkdown(input) {
+    return [
+        `# Delivery Report ${input.taskId}`,
+        "",
+        "## Summary",
+        input.summary,
+        "",
+        "## Verification",
+        ...(input.verification?.length ? input.verification.map((item) => `- ${item}`) : ["- Not recorded."]),
+        "",
+        "## Remaining Risks",
+        ...(input.risks?.length ? input.risks.map((item) => `- ${item}`) : ["- No remaining risks recorded."]),
+    ].join("\n");
+}

package/lib/workflow/workflow-status.d.ts

@@ -0,0 +1,2 @@
+export declare const frontendWorkflowStatuses: readonly ["draft", "context-ready", "plan-ready", "patch-ready", "applied", "verified", "review-ready", "delivered", "failed"];
+export type FrontendWorkflowStatus = typeof frontendWorkflowStatuses[number];

package/lib/workflow/workflow-status.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.frontendWorkflowStatuses = void 0;
+exports.frontendWorkflowStatuses = [
+    "draft",
+    "context-ready",
+    "plan-ready",
+    "patch-ready",
+    "applied",
+    "verified",
+    "review-ready",
+    "delivered",
+    "failed",
+];

package/lib/workflow/workflow-transition.d.ts

@@ -0,0 +1,9 @@
+import type { FrontendWorkflowStatus } from "./workflow-status";
+export declare class WorkflowTransitionError extends Error {
+    readonly from: FrontendWorkflowStatus;
+    readonly to: FrontendWorkflowStatus;
+    constructor(from: FrontendWorkflowStatus, to: FrontendWorkflowStatus);
+}
+export declare function canTransitionWorkflowStatus(from: FrontendWorkflowStatus, to: FrontendWorkflowStatus): boolean;
+export declare function assertWorkflowTransition(from: FrontendWorkflowStatus, to: FrontendWorkflowStatus): void;
+export declare function workflowTransitionReason(from: FrontendWorkflowStatus, to: FrontendWorkflowStatus): string;

package/lib/workflow/workflow-transition.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowTransitionError = void 0;
+exports.canTransitionWorkflowStatus = canTransitionWorkflowStatus;
+exports.assertWorkflowTransition = assertWorkflowTransition;
+exports.workflowTransitionReason = workflowTransitionReason;
+class WorkflowTransitionError extends Error {
+    constructor(from, to) {
+        super(`Illegal workflow status transition: ${from} -> ${to}`);
+        this.from = from;
+        this.to = to;
+    }
+}
+exports.WorkflowTransitionError = WorkflowTransitionError;
+const allowedTransitions = {
+    draft: ["context-ready", "plan-ready", "failed"],
+    "context-ready": ["plan-ready", "failed"],
+    "plan-ready": ["patch-ready", "applied", "failed"],
+    "patch-ready": ["applied", "failed"],
+    applied: ["verified", "failed"],
+    verified: ["review-ready", "delivered", "failed"],
+    "review-ready": ["delivered", "failed"],
+    delivered: [],
+    failed: ["draft"],
+};
+function canTransitionWorkflowStatus(from, to) {
+    if (from === to)
+        return true;
+    return allowedTransitions[from].includes(to);
+}
+function assertWorkflowTransition(from, to) {
+    if (!canTransitionWorkflowStatus(from, to)) {
+        throw new WorkflowTransitionError(from, to);
+    }
+}
+function workflowTransitionReason(from, to) {
+    return `illegal workflow status transition: ${from} -> ${to}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yinuo-ngm/mcp-server",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Local MCP stdio server for ng-manager core capabilities.",
   "author": "ZhangJing <892295834@qq.com>",
   "license": "ISC",
@@ -25,13 +25,15 @@
     "inspect": "npm run build && mcp-inspector node lib/index.js",
     "inspect:dev": "mcp-inspector tsx src/index.ts",
     "dev": "tsx watch src/index.ts",
-    "build": "tsc -b tsconfig.json",
+    "build": "rimraf lib tsconfig.tsbuildinfo && tsc -b tsconfig.json",
+    "lint:tool-names": "tsx scripts/lint-tool-names.ts",
     "test": "npm run build && node --test test",
     "start": "node lib/index.js"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
     "@yinuo-ngm/core": "^0.1.15",
+    "@yinuo-ngm/runtime": "^0.1.3",
     "zod": "^3.25.76"
   },
   "devDependencies": {
@@ -41,5 +43,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "9c45bd57798a539e3b6cf40dd56f7cdffdc02589"
+  "gitHead": "425cb641977ad61c5f535a068f736b8970f79086"
 }

package/lib/tools/hub-v2/config.d.ts

@@ -1,34 +0,0 @@
-export type HubV2ProjectConfig = {
-    name?: string;
-    alias?: string;
-    id?: string;
-    base_url?: string;
-    project_key?: string;
-    project_name?: string;
-    project_token?: string;
-    personal_token?: string;
-    source?: string;
-};
-export type HubV2Config = HubV2ProjectConfig & {
-    default_project?: string;
-    projects?: Record<string, HubV2ProjectConfig>;
-};
-export type HubV2ResolveOptions = {
-    project?: string;
-    projectKey?: string;
-};
-export type HubV2ResolvedContext = {
-    baseUrl: string;
-    projectKey: string;
-    token: string;
-    source: string;
-};
-type TokenKind = "project" | "personal";
-export declare function parseJsonObject(content: string): Record<string, unknown>;
-export declare function loadJsonFile(path: string): Record<string, unknown>;
-export declare function normalizeConfig(rawValue: unknown): HubV2Config;
-export declare function loadConfig(pathValue?: string): HubV2Config;
-export declare function resolveHubV2Context(options: HubV2ResolveOptions, tokenKind: TokenKind, pathValue?: string): HubV2ResolvedContext;
-export declare function listConfiguredProjects(project?: string, pathValue?: string): Record<string, unknown>;
-export declare function getConfiguredProject(options: HubV2ResolveOptions, pathValue?: string): Record<string, unknown>;
-export {};

package/lib/tools/hub-v2/config.js

@@ -1,297 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseJsonObject = parseJsonObject;
-exports.loadJsonFile = loadJsonFile;
-exports.normalizeConfig = normalizeConfig;
-exports.loadConfig = loadConfig;
-exports.resolveHubV2Context = resolveHubV2Context;
-exports.listConfiguredProjects = listConfiguredProjects;
-exports.getConfiguredProject = getConfiguredProject;
-const fs_1 = require("fs");
-const os_1 = require("os");
-const path_1 = require("path");
-function asRecord(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : {};
-}
-function getString(record, ...keys) {
-    for (const key of keys) {
-        const value = record[key];
-        if (value !== undefined && value !== null && String(value).trim()) {
-            return String(value).trim();
-        }
-    }
-    return undefined;
-}
-function putIfValue(target, key, value) {
-    if (value !== undefined && value !== null && String(value).trim()) {
-        target[key] = String(value).trim();
-    }
-}
-function envValue(...names) {
-    for (const name of names) {
-        const value = process.env[name];
-        if (value !== undefined && value !== null && String(value).trim()) {
-            return String(value).trim();
-        }
-    }
-    return undefined;
-}
-function stripJsonComments(input) {
-    let output = "";
-    let inString = false;
-    let stringQuote = "";
-    let escaped = false;
-    for (let index = 0; index < input.length; index += 1) {
-        const char = input[index];
-        const next = input[index + 1];
-        if (inString) {
-            output += char;
-            if (escaped) {
-                escaped = false;
-            }
-            else if (char === "\\") {
-                escaped = true;
-            }
-            else if (char === stringQuote) {
-                inString = false;
-            }
-            continue;
-        }
-        if (char === '"' || char === "'") {
-            inString = true;
-            stringQuote = char;
-            output += char;
-            continue;
-        }
-        if (char === "/" && next === "/") {
-            while (index < input.length && input[index] !== "\n") {
-                index += 1;
-            }
-            output += "\n";
-            continue;
-        }
-        if (char === "/" && next === "*") {
-            index += 2;
-            while (index < input.length && !(input[index] === "*" && input[index + 1] === "/")) {
-                index += 1;
-            }
-            index += 1;
-            continue;
-        }
-        output += char;
-    }
-    return output;
-}
-function parseJsonObject(content) {
-    const parsed = JSON.parse(stripJsonComments(content));
-    return asRecord(parsed);
-}
-function loadJsonFile(path) {
-    if (!(0, fs_1.existsSync)(path)) {
-        return {};
-    }
-    return parseJsonObject((0, fs_1.readFileSync)(path, "utf8"));
-}
-function mergeHubObject(target, value) {
-    const source = asRecord(value);
-    putIfValue(target, "base_url", getString(source, "base_url", "baseUrl"));
-    putIfValue(target, "project_key", getString(source, "project_key", "projectKey"));
-    putIfValue(target, "project_name", getString(source, "project_name", "projectName"));
-    putIfValue(target, "project_token", getString(source, "project_token", "projectToken", "token"));
-    putIfValue(target, "personal_token", getString(source, "personal_token", "personalToken"));
-    putIfValue(target, "source", getString(source, "source"));
-    putIfValue(target, "default_project", getString(source, "default_project", "defaultProject", "project"));
-}
-function mergeEnvObject(target, value) {
-    const env = asRecord(value);
-    putIfValue(target, "base_url", getString(env, "HUB_V2_BASE_URL"));
-    putIfValue(target, "project_key", getString(env, "HUB_V2_PROJECT_KEY"));
-    putIfValue(target, "project_token", getString(env, "HUB_V2_PROJECT_TOKEN"));
-    putIfValue(target, "personal_token", getString(env, "HUB_V2_PERSONAL_TOKEN"));
-    putIfValue(target, "source", getString(env, "HUB_V2_SOURCE"));
-    putIfValue(target, "default_project", getString(env, "HUB_V2_PROJECT"));
-}
-function normalizeProject(raw) {
-    const config = normalizeConfig(raw);
-    const record = asRecord(raw);
-    putIfValue(config, "name", record.name);
-    putIfValue(config, "alias", record.alias);
-    putIfValue(config, "id", record.id);
-    delete config.projects;
-    delete config.default_project;
-    return config;
-}
-function normalizeProjects(raw) {
-    const value = raw.projects;
-    const projects = {};
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-        for (const [name, projectValue] of Object.entries(value)) {
-            const project = normalizeProject(projectValue);
-            const projectName = project.name ?? project.alias ?? name.trim();
-            if (projectName) {
-                projects[projectName] = project;
-            }
-        }
-    }
-    if (Array.isArray(value)) {
-        for (const projectValue of value) {
-            const project = normalizeProject(projectValue);
-            const projectName = project.name ?? project.alias ?? project.id;
-            if (projectName) {
-                projects[projectName] = project;
-            }
-        }
-    }
-    return projects;
-}
-function mergeProjects(...maps) {
-    const merged = {};
-    for (const map of maps) {
-        for (const [name, project] of Object.entries(map)) {
-            merged[name] = { ...(merged[name] ?? {}), ...project };
-        }
-    }
-    return merged;
-}
-function normalizeConfig(rawValue) {
-    const raw = asRecord(rawValue);
-    const normalized = {};
-    mergeHubObject(normalized, raw);
-    mergeHubObject(normalized, raw.hubV2);
-    mergeEnvObject(normalized, raw.env);
-    const projects = mergeProjects(normalizeProjects(raw), normalizeProjects(asRecord(raw.hubV2)));
-    if (Object.keys(projects).length) {
-        normalized.projects = projects;
-    }
-    return normalized;
-}
-function configSearchPaths() {
-    const envConfig = envValue("HUB_V2_CONFIG");
-    if (envConfig) {
-        return [(0, path_1.resolve)(envConfig)];
-    }
-    return [(0, path_1.join)((0, os_1.homedir)(), ".ng-manager", "agent-connections.json")];
-}
-function loadConfig(pathValue) {
-    const paths = pathValue ? [(0, path_1.resolve)(pathValue)] : configSearchPaths();
-    for (const path of paths) {
-        const config = normalizeConfig(loadJsonFile(path));
-        if (Object.keys(config).length) {
-            return config;
-        }
-    }
-    return {};
-}
-function selectedProjectConfig(config, options) {
-    const projects = config.projects ?? {};
-    const entries = Object.entries(projects);
-    if (!entries.length) {
-        return {};
-    }
-    const selected = options.project ?? envValue("HUB_V2_PROJECT") ?? config.default_project;
-    if (selected) {
-        const project = projects[selected];
-        if (!project) {
-            throw new Error(`project config not found: ${selected}. Available projects: ${entries.map(([name]) => name).sort().join(", ")}`);
-        }
-        return project;
-    }
-    if (entries.length === 1) {
-        return entries[0][1];
-    }
-    throw new Error(`multiple projects configured; pass project. Available projects: ${entries.map(([name]) => name).sort().join(", ")}`);
-}
-function configValue(config, projectConfig, key) {
-    return projectConfig[key] ?? config[key];
-}
-function resolveHubV2Context(options, tokenKind, pathValue) {
-    const config = loadConfig(pathValue);
-    const projectConfig = selectedProjectConfig(config, options);
-    const baseUrl = (envValue("HUB_V2_BASE_URL") ??
-        configValue(config, projectConfig, "base_url"))?.replace(/\/+$/, "");
-    const projectKey = options.projectKey ??
-        envValue("HUB_V2_PROJECT_KEY") ??
-        configValue(config, projectConfig, "project_key");
-    const projectToken = envValue("HUB_V2_PROJECT_TOKEN") ??
-        configValue(config, projectConfig, "project_token");
-    const personalToken = envValue("HUB_V2_PERSONAL_TOKEN") ??
-        configValue(config, projectConfig, "personal_token");
-    const source = envValue("HUB_V2_SOURCE") ??
-        configValue(config, projectConfig, "source") ??
-        "ngm-mcp";
-    if (!baseUrl) {
-        throw new Error("HUB_V2_BASE_URL is required");
-    }
-    if (!projectKey) {
-        throw new Error("HUB_V2_PROJECT_KEY is required");
-    }
-    const token = tokenKind === "project" ? projectToken : personalToken;
-    if (!token) {
-        throw new Error(tokenKind === "project" ? "HUB_V2_PROJECT_TOKEN is required" : "HUB_V2_PERSONAL_TOKEN is required");
-    }
-    return { baseUrl, projectKey, token, source };
-}
-function projectSummary(name, config, project) {
-    return {
-        name,
-        projectName: project.project_name,
-        projectKey: project.project_key,
-        baseUrl: project.base_url ?? config.base_url,
-        hasProjectToken: Boolean(project.project_token ?? config.project_token),
-        hasPersonalToken: Boolean(project.personal_token ?? config.personal_token),
-        isDefault: name === config.default_project,
-    };
-}
-function listConfiguredProjects(project, pathValue) {
-    const config = loadConfig(pathValue);
-    const envProjectKey = envValue("HUB_V2_PROJECT_KEY") ?? config.project_key;
-    let items;
-    if (envProjectKey) {
-        items = [
-            {
-                name: envValue("HUB_V2_PROJECT") ?? config.default_project ?? "default",
-                projectName: config.project_name,
-                projectKey: envProjectKey,
-                baseUrl: envValue("HUB_V2_BASE_URL") ?? config.base_url,
-                hasProjectToken: Boolean(envValue("HUB_V2_PROJECT_TOKEN") ?? config.project_token),
-                hasPersonalToken: Boolean(envValue("HUB_V2_PERSONAL_TOKEN") ?? config.personal_token),
-                isDefault: true,
-            },
-        ];
-    }
-    else {
-        const projects = config.projects ?? {};
-        items = Object.entries(projects).map(([name, item]) => projectSummary(name, config, item));
-    }
-    const filtered = project
-        ? items.filter((item) => item.name === project || item.projectName === project || item.projectKey === project)
-        : items;
-    return {
-        items: filtered,
-        total: filtered.length,
-    };
-}
-function getConfiguredProject(options, pathValue) {
-    const config = loadConfig(pathValue);
-    const selected = options.project ?? options.projectKey ?? envValue("HUB_V2_PROJECT") ?? config.default_project;
-    if (selected) {
-        const projects = listConfiguredProjects(selected, pathValue).items;
-        if (projects.length === 1) {
-            return projects[0];
-        }
-        if (!projects.length) {
-            throw new Error("Hub V2 project config not found");
-        }
-        throw new Error("multiple Hub V2 project configs matched");
-    }
-    const projects = listConfiguredProjects(options.project ?? options.projectKey, pathValue).items;
-    if (projects.length === 1) {
-        return projects[0];
-    }
-    if (!projects.length) {
-        throw new Error("Hub V2 project config not found");
-    }
-    throw new Error("multiple Hub V2 project configs matched");
-}