@yinuo-ngm/mcp-server 0.1.2 → 0.1.3

package/lib/tools/workspace-package.js

@@ -0,0 +1,130 @@
+"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.toRelativeWorkspacePath = toRelativeWorkspacePath;
+exports.readPackageJsonSummary = readPackageJsonSummary;
+exports.readOptionalPackageJsonSummary = readOptionalPackageJsonSummary;
+exports.listKnownWorkspacePackages = listKnownWorkspacePackages;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readStringMap(value) {
+    if (!isRecord(value))
+        return {};
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (typeof item === "string") {
+            out[key] = item;
+        }
+    }
+    return out;
+}
+function readUnknownMap(value) {
+    return isRecord(value) ? value : {};
+}
+function toRelativeWorkspacePath(workspaceRoot, filePath) {
+    return path.relative(workspaceRoot, filePath).replace(/\\/g, "/") || ".";
+}
+async function readPackageJsonSummary(workspaceRoot, packageDir) {
+    const resolvedDir = path.resolve(packageDir);
+    const packageJsonPath = path.join(resolvedDir, "package.json");
+    const raw = await fs.readFile(packageJsonPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!isRecord(parsed)) {
+        throw new Error(`package.json must be an object: ${packageJsonPath}`);
+    }
+    return {
+        name: typeof parsed.name === "string" ? parsed.name : undefined,
+        version: typeof parsed.version === "string" ? parsed.version : undefined,
+        private: typeof parsed.private === "boolean" ? parsed.private : undefined,
+        description: typeof parsed.description === "string" ? parsed.description : undefined,
+        path: toRelativeWorkspacePath(workspaceRoot, resolvedDir),
+        packageJsonPath: toRelativeWorkspacePath(workspaceRoot, packageJsonPath),
+        scripts: readStringMap(parsed.scripts),
+        engines: readUnknownMap(parsed.engines),
+        dependencies: readStringMap(parsed.dependencies),
+        devDependencies: readStringMap(parsed.devDependencies),
+        peerDependencies: readStringMap(parsed.peerDependencies),
+        workspaces: parsed.workspaces,
+        bin: parsed.bin,
+        main: typeof parsed.main === "string" ? parsed.main : undefined,
+        types: typeof parsed.types === "string" ? parsed.types : undefined,
+        exports: parsed.exports,
+    };
+}
+async function readOptionalPackageJsonSummary(workspaceRoot, packageDir) {
+    try {
+        return await readPackageJsonSummary(workspaceRoot, packageDir);
+    }
+    catch {
+        return null;
+    }
+}
+async function listKnownWorkspacePackages(workspaceRoot) {
+    const roots = new Set([
+        workspaceRoot,
+        path.join(workspaceRoot, "webapp"),
+        path.join(workspaceRoot, "desktop"),
+        path.join(workspaceRoot, "apps", "hub"),
+        path.join(workspaceRoot, "apps", "hub-v2"),
+        path.join(workspaceRoot, "apps", "site"),
+    ]);
+    const packagesDir = path.join(workspaceRoot, "packages");
+    try {
+        const entries = await fs.readdir(packagesDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                roots.add(path.join(packagesDir, entry.name));
+            }
+        }
+    }
+    catch {
+    }
+    const appsDir = path.join(workspaceRoot, "apps");
+    try {
+        const entries = await fs.readdir(appsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                roots.add(path.join(appsDir, entry.name));
+            }
+        }
+    }
+    catch {
+    }
+    const packages = await Promise.all([...roots].map((root) => readOptionalPackageJsonSummary(workspaceRoot, root)));
+    return packages.filter((item) => item !== null).sort((a, b) => a.path.localeCompare(b.path));
+}

package/lib/tools/workspace.tools.d.ts

@@ -0,0 +1,7 @@
+import type { McpToolDefinition } from "./index";
+export declare function truncateUtf8(text: string, maxBytes: number): {
+    text: string;
+    truncated: boolean;
+};
+export declare function workspaceTools(): McpToolDefinition[];
+export declare function readWorkspacePackageJson(workspaceRoot: string, packageDir: string): Promise<import("./workspace-package").PackageJsonSummary>;

package/lib/tools/workspace.tools.js

@@ -0,0 +1,336 @@
+"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.truncateUtf8 = truncateUtf8;
+exports.workspaceTools = workspaceTools;
+exports.readWorkspacePackageJson = readWorkspacePackageJson;
+const path = __importStar(require("path"));
+const zod_1 = require("zod");
+const result_1 = require("../utils/result");
+const project_files_1 = require("../filesystem/project-files");
+const redact_1 = require("../audit/redact");
+const tool_catalog_1 = require("./tool-catalog");
+const workspace_package_1 = require("./workspace-package");
+const getPackageSchema = zod_1.z.object({
+    name: zod_1.z.string().trim().min(1).optional(),
+    path: zod_1.z.string().trim().min(1).optional(),
+}).strict();
+const workspaceDiffSchema = zod_1.z.object({
+    projectId: zod_1.z.string().trim().min(1).optional(),
+    projectPath: zod_1.z.string().trim().min(1).optional(),
+    includePatch: zod_1.z.boolean().optional(),
+    maxBytes: zod_1.z.number().int().min(1).max(200000).optional(),
+}).strict();
+const patchPreviewSchema = zod_1.z.object({
+    projectId: zod_1.z.string().trim().min(1).optional(),
+    projectPath: zod_1.z.string().trim().min(1).optional(),
+    patch: zod_1.z.string().min(1),
+}).strict();
+function normalizePath(value) {
+    return value.replace(/\\/g, "/").replace(/^\.?\//, "").toLowerCase();
+}
+function isForbiddenWorkspacePath(filePath) {
+    const normalized = filePath.replace(/\\/g, "/").replace(/^\.?\//, "");
+    const parts = normalized.split("/");
+    return parts.some((part) => ["node_modules", "dist", "build", ".git", "coverage", ".cache", ".angular", ".idea"].includes(part))
+        || parts.some((part) => part === ".env" || part.startsWith(".env."))
+        || normalized.endsWith(".pem")
+        || normalized.endsWith(".key")
+        || normalized.endsWith(".p12")
+        || normalized.endsWith(".pfx")
+        || normalized.endsWith(".jks")
+        || normalized.endsWith(".keystore");
+}
+function assertWorkspaceReadablePath(projectRoot, filePath) {
+    const normalized = filePath.replace(/\\/g, "/").replace(/^a\//, "").replace(/^b\//, "");
+    if (!normalized || normalized === "/dev/null")
+        return normalized;
+    if (path.isAbsolute(normalized) || normalized.includes("..")) {
+        throw new Error(`Patch path is not project-relative: ${filePath}`);
+    }
+    if (isForbiddenWorkspacePath(normalized)) {
+        throw new Error(`Patch path is forbidden for workspace preview: ${filePath}`);
+    }
+    const resolved = path.resolve(projectRoot, normalized);
+    (0, project_files_1.assertPathInsideProject)(projectRoot, resolved);
+    return (0, project_files_1.projectRelativePath)(projectRoot, resolved);
+}
+function summarizeDiffText(diffText, projectRoot) {
+    if (/^GIT binary patch$/m.test(diffText) || /^Binary files\b/m.test(diffText)) {
+        throw new Error("Binary patch is not supported by workspace preview");
+    }
+    const changed = new Set();
+    let addedLines = 0;
+    let removedLines = 0;
+    for (const line of diffText.split(/\r?\n/)) {
+        const diffMatch = /^diff --git a\/(.+?) b\/(.+)$/.exec(line);
+        if (diffMatch) {
+            changed.add(assertWorkspaceReadablePath(projectRoot, diffMatch[2]));
+            continue;
+        }
+        const fileMatch = /^(?:---|\+\+\+) (?:a|b)\/(.+)$/.exec(line);
+        if (fileMatch) {
+            changed.add(assertWorkspaceReadablePath(projectRoot, fileMatch[1]));
+            continue;
+        }
+        if (line.startsWith("+++") || line.startsWith("---"))
+            continue;
+        if (line.startsWith("+"))
+            addedLines += 1;
+        if (line.startsWith("-"))
+            removedLines += 1;
+    }
+    const changedFiles = [...changed].filter((item) => item !== "/dev/null").sort();
+    return {
+        changedFiles,
+        addedLines,
+        removedLines,
+        summary: changedFiles.length
+            ? `${changedFiles.length} file(s), +${addedLines}/-${removedLines}`
+            : `0 file(s), +${addedLines}/-${removedLines}`,
+    };
+}
+function truncateUtf8(text, maxBytes) {
+    if (Buffer.byteLength(text, "utf-8") <= maxBytes) {
+        return { text, truncated: false };
+    }
+    let end = Math.min(text.length, maxBytes);
+    while (end > 0 && Buffer.byteLength(text.slice(0, end), "utf-8") > maxBytes) {
+        end -= 1;
+    }
+    while (end > 0) {
+        const last = text.charCodeAt(end - 1);
+        if (last < 0xd800 || last > 0xdbff)
+            break;
+        end -= 1;
+    }
+    return { text: text.slice(0, end), truncated: true };
+}
+function patchPreview(diffText, maxBytes) {
+    const redacted = (0, redact_1.redactText)(diffText);
+    const truncated = truncateUtf8(redacted, maxBytes);
+    return {
+        patchPreview: truncated.text,
+        truncated: truncated.truncated,
+    };
+}
+function capabilityMap() {
+    return [
+        {
+            area: "packages/mcp-server",
+            capability: "Agent-facing MCP adapter and tool exposure",
+            skill: "ngm-workspace",
+            notes: "Keep tools as thin adapters over core services where possible.",
+        },
+        {
+            area: "packages/project",
+            capability: "Local project records and workspace detection",
+            skill: "ngm-project",
+        },
+        {
+            area: "packages/task",
+            capability: "Package script task views, runtime state, and log streaming",
+            skill: "ngm-project",
+        },
+        {
+            area: "packages/node-runtime, packages/node-version",
+            capability: "Node runtime resolution and project Node requirement detection",
+            skill: "ngm-runtime",
+        },
+        {
+            area: "packages/nginx",
+            capability: "Local Nginx binding, server blocks, upstreams, validation, and logs",
+            skill: "ngm-nginx",
+        },
+        {
+            area: "packages/api, webapp/src/app/pages/api-client",
+            capability: "Local API debugging data and UI",
+            skill: "ngm-workspace",
+        },
+        {
+            area: "packages/design-handoff",
+            capability: "Design handoff package validation and task generation",
+            skill: "ngm-workspace",
+        },
+        {
+            area: "webapp",
+            capability: "Single frontend used by CLI and desktop launch modes",
+            skill: "ngm-workspace",
+        },
+        {
+            area: "packages/server",
+            capability: "Single local backend authority for runtime state and APIs",
+            skill: "ngm-workspace",
+        },
+        {
+            area: "packages/cli, desktop",
+            capability: "Thin local entry points for the same backend/frontend product",
+            skill: "ngm-workspace",
+        },
+        {
+            area: "apps/hub-v2",
+            capability: "Hub V2 collaboration platform server/web business logic",
+            skill: "hub-v2-api",
+        },
+    ];
+}
+function workspaceTools() {
+    return [
+        {
+            name: "ngm_workspace_summary",
+            description: "Summarize the local ng-manager workspace root, major app/package areas, and MCP read-only discovery status.",
+            riskLevel: "read",
+            inputSchema: zod_1.z.object({}).strict(),
+            async handler(_args, context) {
+                const packages = await (0, workspace_package_1.listKnownWorkspacePackages)(context.workspaceRoot);
+                return (0, result_1.ok)("ngm_workspace_summary", {
+                    workspaceRoot: context.workspaceRoot,
+                    dataDir: context.dataDir,
+                    packageCount: packages.length,
+                    packageNames: packages.map((item) => item.name).filter(Boolean),
+                    majorAreas: capabilityMap(),
+                    readOnlyPhase: true,
+                    codeGraph: {
+                        exposedByThisMcpServer: false,
+                        guidance: "Use external CodeGraph MCP tools when available; this server exposes workspace and package metadata only.",
+                    },
+                });
+            },
+        },
+        {
+            name: "ngm_workspace_list_packages",
+            description: "List package.json metadata from known ng-manager workspace package and app roots.",
+            riskLevel: "read",
+            inputSchema: zod_1.z.object({}).strict(),
+            async handler(_args, context) {
+                const packages = await (0, workspace_package_1.listKnownWorkspacePackages)(context.workspaceRoot);
+                return (0, result_1.ok)("ngm_workspace_list_packages", packages);
+            },
+        },
+        {
+            name: "ngm_workspace_get_package",
+            description: "Get package.json metadata for one known ng-manager workspace package or app by name or relative path.",
+            riskLevel: "read",
+            inputSchema: getPackageSchema,
+            async handler(args, context) {
+                if (!args.name && !args.path) {
+                    throw new Error("name or path is required");
+                }
+                const packages = await (0, workspace_package_1.listKnownWorkspacePackages)(context.workspaceRoot);
+                const requestedPath = args.path ? normalizePath(args.path) : "";
+                const found = packages.find((item) => {
+                    if (args.name && item.name === args.name)
+                        return true;
+                    if (!requestedPath)
+                        return false;
+                    return normalizePath(item.path) === requestedPath || normalizePath(item.packageJsonPath) === requestedPath;
+                });
+                if (!found) {
+                    throw new Error(`Workspace package not found: ${args.name || args.path}`);
+                }
+                return (0, result_1.ok)("ngm_workspace_get_package", found);
+            },
+        },
+        {
+            name: "ngm_workspace_mcp_tools",
+            description: "List ng-manager MCP tools with skill, capability, and risk-level mapping.",
+            riskLevel: "read",
+            inputSchema: zod_1.z.object({}).strict(),
+            handler() {
+                return (0, result_1.ok)("ngm_workspace_mcp_tools", tool_catalog_1.toolCatalog);
+            },
+        },
+        {
+            name: "ngm_workspace_capability_map",
+            description: "Map ng-manager workspace areas and MCP capability groups to the correct NGM or Hub V2 skill.",
+            riskLevel: "read",
+            inputSchema: zod_1.z.object({}).strict(),
+            handler() {
+                return (0, result_1.ok)("ngm_workspace_capability_map", {
+                    areas: capabilityMap(),
+                    capabilities: tool_catalog_1.capabilityCatalog,
+                });
+            },
+        },
+        {
+            name: "ngm_workspace_diff",
+            description: "Read a safe Git diff summary for a project without exposing forbidden workspace paths.",
+            riskLevel: "read",
+            inputSchema: workspaceDiffSchema,
+            async handler(args, context) {
+                const project = await (0, project_files_1.resolveProjectRoot)(context, args);
+                const maxBytes = args.maxBytes ?? 20000;
+                const gitArgs = { ...args, projectPath: project.projectRoot };
+                const diff = await context.services.git.diff(gitArgs);
+                const diffText = typeof diff.diff === "string" ? diff.diff : JSON.stringify(diff);
+                const summary = summarizeDiffText(diffText, project.projectRoot);
+                const includePatch = args.includePatch === true;
+                const preview = includePatch ? patchPreview(diffText, maxBytes) : undefined;
+                return (0, result_1.ok)("ngm_workspace_diff", {
+                    project,
+                    ...summary,
+                    ...(preview ? {
+                        ...preview,
+                        maxBytes,
+                        truncated: Boolean(diff.truncated) || preview.truncated,
+                    } : {}),
+                });
+            },
+        },
+        {
+            name: "ngm_workspace_apply_patch_preview",
+            description: "Preview a unified patch without writing files. It rejects forbidden paths and returns changed files plus added/removed line counts.",
+            riskLevel: "read",
+            inputSchema: patchPreviewSchema,
+            async handler(args, context) {
+                const project = await (0, project_files_1.resolveProjectRoot)(context, args);
+                const summary = summarizeDiffText(args.patch, project.projectRoot);
+                return (0, result_1.ok)("ngm_workspace_apply_patch_preview", {
+                    project,
+                    operation: {
+                        status: "preview",
+                        type: "write",
+                        risk: "medium",
+                        safetyMessage: "Patch preview only; no file writes are performed.",
+                    },
+                    ...summary,
+                });
+            },
+        },
+    ];
+}
+async function readWorkspacePackageJson(workspaceRoot, packageDir) {
+    return (0, workspace_package_1.readPackageJsonSummary)(workspaceRoot, path.resolve(packageDir));
+}

package/lib/utils/errors.js

@@ -13,8 +13,13 @@ function errorMetadata(error) {
         return {};
     }
     const record = error;
+    const code = typeof record.errorCode === "string"
+        ? record.errorCode
+        : typeof record.code === "string"
+            ? record.code
+            : undefined;
     return {
-        code: typeof record.code === "string" ? record.code : undefined,
+        code,
         status: typeof record.status === "number" ? record.status : undefined,
         detail: record.detail,
     };

package/lib/utils/result.d.ts

@@ -7,12 +7,17 @@ export type ToolErrorResult = {
     ok: false;
     tool: string;
     error: string;
+    errorCode?: string;
     code?: string;
     status?: number;
     detail?: unknown;
 };
 export type ToolResult<T = unknown> = (ToolSuccessResult<T> | ToolErrorResult) & {
     truncated?: true;
+    auditWarning?: {
+        code: string;
+        message: string;
+    };
 };
 export declare function ok<T>(tool: string, data: T): ToolSuccessResult<T>;
 export declare function fail(tool: string, error: string, metadata?: {
@@ -20,6 +25,10 @@ export declare function fail(tool: string, error: string, metadata?: {
     status?: number;
     detail?: unknown;
 }): ToolErrorResult;
+export declare function withAuditWarning(result: ToolResult, warning: {
+    code: string;
+    message: string;
+}): ToolResult;
 export declare function toMcpTextResult(result: ToolResult): {
     content: Array<{
         type: "text";

package/lib/utils/result.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ok = ok;
 exports.fail = fail;
+exports.withAuditWarning = withAuditWarning;
 exports.toMcpTextResult = toMcpTextResult;
 function ok(tool, data) {
     return { ok: true, tool, data };
@@ -11,11 +12,18 @@ function fail(tool, error, metadata = {}) {
         ok: false,
         tool,
         error,
+        ...(metadata.code ? { errorCode: metadata.code } : {}),
         ...(metadata.code ? { code: metadata.code } : {}),
         ...(metadata.status ? { status: metadata.status } : {}),
         ...(metadata.detail !== undefined ? { detail: metadata.detail } : {}),
     };
 }
+function withAuditWarning(result, warning) {
+    return {
+        ...result,
+        auditWarning: warning,
+    };
+}
 function toMcpTextResult(result) {
     const maxChars = maxResultChars();
     const text = JSON.stringify(result, null, 2);
@@ -59,6 +67,7 @@ function buildTruncatedResult(result, originalLength, preview) {
         ok: false,
         tool: result.tool,
         error: result.error,
+        errorCode: result.errorCode ?? result.code,
         code: result.code,
         status: result.status,
         truncated: true,

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

@@ -0,0 +1,83 @@
+import { z } from "zod";
+export declare const workflowCheckStatusSchema: z.ZodEnum<["pending", "passed", "warning", "failed", "blocked"]>;
+export declare const workflowChecksSchema: z.ZodObject<{
+    standard: z.ZodEnum<["pending", "passed", "warning", "failed", "blocked"]>;
+    test: z.ZodEnum<["pending", "passed", "warning", "failed", "blocked"]>;
+    review: z.ZodEnum<["pending", "passed", "warning", "failed", "blocked"]>;
+    build: z.ZodEnum<["pending", "passed", "warning", "failed", "blocked"]>;
+}, "strict", z.ZodTypeAny, {
+    standard: "warning" | "passed" | "failed" | "blocked" | "pending";
+    review: "warning" | "passed" | "failed" | "blocked" | "pending";
+    test: "warning" | "passed" | "failed" | "blocked" | "pending";
+    build: "warning" | "passed" | "failed" | "blocked" | "pending";
+}, {
+    standard: "warning" | "passed" | "failed" | "blocked" | "pending";
+    review: "warning" | "passed" | "failed" | "blocked" | "pending";
+    test: "warning" | "passed" | "failed" | "blocked" | "pending";
+    build: "warning" | "passed" | "failed" | "blocked" | "pending";
+}>;
+export declare const frontendTaskSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    status: z.ZodEnum<["draft", "context-ready", "plan-ready", "patch-ready", "applied", "verified", "review-ready", "delivered", "failed"]>;
+    projectId: z.ZodOptional<z.ZodString>;
+    projectRoot: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    designContextPath: z.ZodNullable<z.ZodString>;
+    changedFiles: z.ZodArray<z.ZodString, "many">;
+    checks: z.ZodObject<{
+        standard: z.ZodEnum<["pending", "passed", "warning", "failed", "blocked"]>;
+        test: z.ZodEnum<["pending", "passed", "warning", "failed", "blocked"]>;
+        review: z.ZodEnum<["pending", "passed", "warning", "failed", "blocked"]>;
+        build: z.ZodEnum<["pending", "passed", "warning", "failed", "blocked"]>;
+    }, "strict", z.ZodTypeAny, {
+        standard: "warning" | "passed" | "failed" | "blocked" | "pending";
+        review: "warning" | "passed" | "failed" | "blocked" | "pending";
+        test: "warning" | "passed" | "failed" | "blocked" | "pending";
+        build: "warning" | "passed" | "failed" | "blocked" | "pending";
+    }, {
+        standard: "warning" | "passed" | "failed" | "blocked" | "pending";
+        review: "warning" | "passed" | "failed" | "blocked" | "pending";
+        test: "warning" | "passed" | "failed" | "blocked" | "pending";
+        build: "warning" | "passed" | "failed" | "blocked" | "pending";
+    }>;
+}, "strict", z.ZodTypeAny, {
+    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;
+}, {
+    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;
+}>;
+export type FrontendTask = z.infer<typeof frontendTaskSchema>;
+export type WorkflowCheckStatus = z.infer<typeof workflowCheckStatusSchema>;
+export type WorkflowChecks = z.infer<typeof workflowChecksSchema>;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.frontendTaskSchema = exports.workflowChecksSchema = exports.workflowCheckStatusSchema = void 0;
+const zod_1 = require("zod");
+const workflow_status_1 = require("./workflow-status");
+exports.workflowCheckStatusSchema = zod_1.z.enum(["pending", "passed", "warning", "failed", "blocked"]);
+exports.workflowChecksSchema = zod_1.z.object({
+    standard: exports.workflowCheckStatusSchema,
+    test: exports.workflowCheckStatusSchema,
+    review: exports.workflowCheckStatusSchema,
+    build: exports.workflowCheckStatusSchema,
+}).strict();
+exports.frontendTaskSchema = zod_1.z.object({
+    taskId: zod_1.z.string().min(1),
+    status: zod_1.z.enum(workflow_status_1.frontendWorkflowStatuses),
+    projectId: zod_1.z.string().optional(),
+    projectRoot: zod_1.z.string(),
+    title: zod_1.z.string().min(1),
+    description: zod_1.z.string(),
+    createdAt: zod_1.z.string(),
+    updatedAt: zod_1.z.string(),
+    designContextPath: zod_1.z.string().nullable(),
+    changedFiles: zod_1.z.array(zod_1.z.string()),
+    checks: exports.workflowChecksSchema,
+}).strict();