@wp-typia/project-tools 0.22.3 → 0.22.4

package/dist/runtime/ts-source-masking.js

@@ -0,0 +1,104 @@
+function maskSourceSegment(segment) {
+    return segment.replace(/[^\n\r]/gu, " ");
+}
+function testPattern(source, pattern) {
+    pattern.lastIndex = 0;
+    const matched = pattern.test(source);
+    pattern.lastIndex = 0;
+    return matched;
+}
+/**
+ * Masks TypeScript comments with spaces while preserving newlines and offsets.
+ */
+export function maskTypeScriptComments(source) {
+    return source
+        .replace(/\/\*[\s\S]*?\*\//gu, maskSourceSegment)
+        .replace(/\/\/[^\n\r]*/gu, maskSourceSegment);
+}
+/**
+ * Masks TypeScript comments and quoted/template literals with spaces while
+ * preserving source offsets. This is a lightweight lexer for runtime checks,
+ * not a full TypeScript parser, so template interpolation and regex/division
+ * ambiguity are intentionally left to callers that need deeper syntax analysis.
+ */
+export function maskTypeScriptCommentsAndLiterals(source) {
+    let maskedSource = "";
+    let index = 0;
+    while (index < source.length) {
+        const current = source[index];
+        const next = source[index + 1];
+        if (current === "/" && next === "/") {
+            const start = index;
+            index += 2;
+            while (index < source.length &&
+                source[index] !== "\n" &&
+                source[index] !== "\r") {
+                index += 1;
+            }
+            maskedSource += maskSourceSegment(source.slice(start, index));
+            continue;
+        }
+        if (current === "/" && next === "*") {
+            const start = index;
+            index += 2;
+            while (index < source.length &&
+                !(source[index] === "*" && source[index + 1] === "/")) {
+                index += 1;
+            }
+            index = Math.min(index + 2, source.length);
+            maskedSource += maskSourceSegment(source.slice(start, index));
+            continue;
+        }
+        if (current === "'" || current === '"' || current === "`") {
+            const start = index;
+            const quote = current;
+            index += 1;
+            while (index < source.length) {
+                const char = source[index];
+                if (char === "\\") {
+                    index += 2;
+                    continue;
+                }
+                index += 1;
+                if (char === quote) {
+                    break;
+                }
+            }
+            maskedSource += maskSourceSegment(source.slice(start, index));
+            continue;
+        }
+        maskedSource += current;
+        index += 1;
+    }
+    return maskedSource;
+}
+/**
+ * Tests for a pattern after hiding comments and quoted/template literals.
+ */
+export function hasExecutablePattern(source, pattern) {
+    return testPattern(maskTypeScriptCommentsAndLiterals(source), pattern);
+}
+/**
+ * Tests for a pattern after hiding comments while leaving literals intact.
+ */
+export function hasUncommentedPattern(source, pattern) {
+    return testPattern(maskTypeScriptComments(source), pattern);
+}
+/**
+ * Finds the first masked-source match that maps back to the original source.
+ */
+export function findExecutablePatternMatch(source, patterns) {
+    const maskedSource = maskTypeScriptCommentsAndLiterals(source);
+    for (const pattern of patterns) {
+        pattern.lastIndex = 0;
+        const match = pattern.exec(maskedSource);
+        pattern.lastIndex = 0;
+        if (match && match.index !== undefined) {
+            return {
+                end: match.index + match[0].length,
+                start: match.index,
+            };
+        }
+    }
+    return undefined;
+}

package/dist/runtime/typia-llm.d.ts

@@ -1,6 +1,6 @@
 import type { ArtifactSyncExecutionOptions, EndpointManifestDefinition, EndpointManifestEndpointDefinition } from '@wp-typia/block-runtime/metadata-core';
 import type { ILlmFunction, ILlmSchema, ILlmStructuredOutput } from 'typia';
-import { type EndpointAuthIntent, type EndpointWordPressAuthDefinition, type OpenApiDocument } from './schema-core.js';
+import { type EndpointAuthIntent, type EndpointWordPressAuthDefinition, type JsonSchemaObject, type OpenApiDocument } from './schema-core.js';
 /**
  * Method-level descriptor projected from an endpoint manifest for a generated
  * `typia.llm` controller interface.
@@ -186,6 +186,14 @@ export interface ProjectTypiaLlmStructuredOutputArtifactOptions {
     /** Compiled structured-output value produced by `typia.llm.structuredOutput(...)`. */
     structuredOutput: TypiaLlmStructuredOutputLike;
 }
+/**
+ * Narrow a `typia.llm` artifact field before applying JSON Schema mutations.
+ *
+ * @param value Candidate schema value emitted by `typia.llm`.
+ * @param context Human-readable artifact path for diagnostics.
+ * @returns The value narrowed to the shared JSON Schema object shape.
+ */
+export declare function assertJsonSchemaObject(value: unknown, context: string): JsonSchemaObject;
 /**
  * Builds the generated controller method descriptors that bridge endpoint
  * manifests to `typia.llm` TypeScript interfaces.

package/dist/runtime/typia-llm.js

@@ -105,6 +105,19 @@ function cloneJsonValueIfDefined(value) {
 function isJsonSchemaObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+/**
+ * Narrow a `typia.llm` artifact field before applying JSON Schema mutations.
+ *
+ * @param value Candidate schema value emitted by `typia.llm`.
+ * @param context Human-readable artifact path for diagnostics.
+ * @returns The value narrowed to the shared JSON Schema object shape.
+ */
+export function assertJsonSchemaObject(value, context) {
+    if (isJsonSchemaObject(value)) {
+        return value;
+    }
+    throw new Error(`${context} must be a JSON Schema object.`);
+}
 function decodeJsonPointerSegment(segment) {
     return segment.replace(/~1/g, '/').replace(/~0/g, '~');
 }
@@ -551,23 +564,25 @@ export function applyOpenApiConstraintsToTypiaLlmFunctionArtifact({ functionArti
             typeof resolvedParameter.name === 'string');
     });
     const requestBodySchema = resolveOpenApiRequestBodySchema(operation, openApiDocument);
+    const parameterSchema = assertJsonSchemaObject(constrainedArtifact.parameters, `typia.llm parameters for "${constrainedArtifact.name}"`);
     if (requestBodySchema) {
         if (hasQueryParameters) {
-            mergeJsonSchemaConstraintProperties(openApiDocument, getOrCreateObjectProperty(constrainedArtifact.parameters, 'body'), requestBodySchema);
+            mergeJsonSchemaConstraintProperties(openApiDocument, getOrCreateObjectProperty(parameterSchema, 'body'), requestBodySchema);
         }
         else {
-            mergeJsonSchemaConstraintProperties(openApiDocument, constrainedArtifact.parameters, requestBodySchema);
+            mergeJsonSchemaConstraintProperties(openApiDocument, parameterSchema, requestBodySchema);
         }
     }
     if (hasQueryParameters) {
         applyOpenApiQueryParameterConstraints(requestBodySchema
-            ? getOrCreateObjectProperty(constrainedArtifact.parameters, 'query')
-            : constrainedArtifact.parameters, operation, openApiDocument);
+            ? getOrCreateObjectProperty(parameterSchema, 'query')
+            : parameterSchema, operation, openApiDocument);
     }
     if (constrainedArtifact.output) {
+        const outputSchema = assertJsonSchemaObject(constrainedArtifact.output, `typia.llm output for "${constrainedArtifact.name}"`);
         const responseSchema = resolveOpenApiSuccessResponseSchema(operation, openApiDocument);
         if (responseSchema) {
-            mergeJsonSchemaConstraintProperties(openApiDocument, constrainedArtifact.output, responseSchema);
+            mergeJsonSchemaConstraintProperties(openApiDocument, outputSchema, responseSchema);
         }
     }
     return constrainedArtifact;

package/dist/runtime/workspace-inventory.js

@@ -202,6 +202,108 @@ export const EDITOR_PLUGINS: WorkspaceEditorPluginConfig[] = [
 \t// wp-typia add editor-plugin entries
 ];
 `;
+const INVENTORY_SECTIONS = [
+    {
+        interface: {
+            name: "WorkspaceVariationConfig",
+            section: VARIATIONS_INTERFACE_SECTION,
+        },
+        value: {
+            name: "VARIATIONS",
+            section: VARIATIONS_CONST_SECTION,
+        },
+    },
+    {
+        interface: {
+            name: "WorkspaceBlockStyleConfig",
+            section: BLOCK_STYLES_INTERFACE_SECTION,
+        },
+        value: {
+            name: "BLOCK_STYLES",
+            section: BLOCK_STYLES_CONST_SECTION,
+        },
+    },
+    {
+        interface: {
+            name: "WorkspaceBlockTransformConfig",
+            section: BLOCK_TRANSFORMS_INTERFACE_SECTION,
+        },
+        value: {
+            name: "BLOCK_TRANSFORMS",
+            section: BLOCK_TRANSFORMS_CONST_SECTION,
+        },
+    },
+    {
+        interface: {
+            name: "WorkspacePatternConfig",
+            section: PATTERNS_INTERFACE_SECTION,
+        },
+        value: {
+            name: "PATTERNS",
+            section: PATTERNS_CONST_SECTION,
+        },
+    },
+    {
+        interface: {
+            name: "WorkspaceBindingSourceConfig",
+            section: BINDING_SOURCES_INTERFACE_SECTION,
+        },
+        value: {
+            name: "BINDING_SOURCES",
+            section: BINDING_SOURCES_CONST_SECTION,
+        },
+    },
+    {
+        interface: {
+            name: "WorkspaceRestResourceConfig",
+            section: REST_RESOURCES_INTERFACE_SECTION,
+        },
+        value: {
+            name: "REST_RESOURCES",
+            section: REST_RESOURCES_CONST_SECTION,
+        },
+    },
+    {
+        interface: {
+            name: "WorkspaceAbilityConfig",
+            section: ABILITIES_INTERFACE_SECTION,
+        },
+        value: {
+            name: "ABILITIES",
+            section: ABILITIES_CONST_SECTION,
+        },
+    },
+    {
+        interface: {
+            name: "WorkspaceAiFeatureConfig",
+            section: AI_FEATURES_INTERFACE_SECTION,
+        },
+        value: {
+            name: "AI_FEATURES",
+            section: AI_FEATURES_CONST_SECTION,
+        },
+    },
+    {
+        interface: {
+            name: "WorkspaceAdminViewConfig",
+            section: ADMIN_VIEWS_INTERFACE_SECTION,
+        },
+        value: {
+            name: "ADMIN_VIEWS",
+            section: ADMIN_VIEWS_CONST_SECTION,
+        },
+    },
+    {
+        interface: {
+            name: "WorkspaceEditorPluginConfig",
+            section: EDITOR_PLUGINS_INTERFACE_SECTION,
+        },
+        value: {
+            name: "EDITOR_PLUGINS",
+            section: EDITOR_PLUGINS_CONST_SECTION,
+        },
+    },
+];
 function getPropertyNameText(name) {
     if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
         return name.text;
@@ -576,68 +678,23 @@ export function getWorkspaceBlockSelectOptions(projectDir) {
 }
 function ensureWorkspaceInventorySections(source) {
     let nextSource = source.trimEnd();
-    if (!/export\s+interface\s+WorkspaceVariationConfig\b/u.test(nextSource)) {
-        nextSource += VARIATIONS_INTERFACE_SECTION;
-    }
-    if (!/export\s+const\s+VARIATIONS\b/u.test(nextSource)) {
-        nextSource += VARIATIONS_CONST_SECTION;
-    }
-    if (!/export\s+interface\s+WorkspaceBlockStyleConfig\b/u.test(nextSource)) {
-        nextSource += BLOCK_STYLES_INTERFACE_SECTION;
-    }
-    if (!/export\s+const\s+BLOCK_STYLES\b/u.test(nextSource)) {
-        nextSource += BLOCK_STYLES_CONST_SECTION;
-    }
-    if (!/export\s+interface\s+WorkspaceBlockTransformConfig\b/u.test(nextSource)) {
-        nextSource += BLOCK_TRANSFORMS_INTERFACE_SECTION;
-    }
-    if (!/export\s+const\s+BLOCK_TRANSFORMS\b/u.test(nextSource)) {
-        nextSource += BLOCK_TRANSFORMS_CONST_SECTION;
-    }
-    if (!/export\s+interface\s+WorkspacePatternConfig\b/u.test(nextSource)) {
-        nextSource += PATTERNS_INTERFACE_SECTION;
-    }
-    if (!/export\s+const\s+PATTERNS\b/u.test(nextSource)) {
-        nextSource += PATTERNS_CONST_SECTION;
-    }
-    if (!/export\s+interface\s+WorkspaceBindingSourceConfig\b/u.test(nextSource)) {
-        nextSource += BINDING_SOURCES_INTERFACE_SECTION;
-    }
-    if (!/export\s+const\s+BINDING_SOURCES\b/u.test(nextSource)) {
-        nextSource += BINDING_SOURCES_CONST_SECTION;
-    }
-    if (!/export\s+interface\s+WorkspaceRestResourceConfig\b/u.test(nextSource)) {
-        nextSource += REST_RESOURCES_INTERFACE_SECTION;
-    }
-    if (!/export\s+const\s+REST_RESOURCES\b/u.test(nextSource)) {
-        nextSource += REST_RESOURCES_CONST_SECTION;
-    }
-    if (!/export\s+interface\s+WorkspaceAbilityConfig\b/u.test(nextSource)) {
-        nextSource += ABILITIES_INTERFACE_SECTION;
-    }
-    if (!/export\s+const\s+ABILITIES\b/u.test(nextSource)) {
-        nextSource += ABILITIES_CONST_SECTION;
-    }
-    if (!/export\s+interface\s+WorkspaceAiFeatureConfig\b/u.test(nextSource)) {
-        nextSource += AI_FEATURES_INTERFACE_SECTION;
-    }
-    if (!/export\s+const\s+AI_FEATURES\b/u.test(nextSource)) {
-        nextSource += AI_FEATURES_CONST_SECTION;
-    }
-    if (!/export\s+interface\s+WorkspaceAdminViewConfig\b/u.test(nextSource)) {
-        nextSource += ADMIN_VIEWS_INTERFACE_SECTION;
-    }
-    if (!/export\s+const\s+ADMIN_VIEWS\b/u.test(nextSource)) {
-        nextSource += ADMIN_VIEWS_CONST_SECTION;
-    }
-    if (!/export\s+interface\s+WorkspaceEditorPluginConfig\b/u.test(nextSource)) {
-        nextSource += EDITOR_PLUGINS_INTERFACE_SECTION;
-    }
-    if (!/export\s+const\s+EDITOR_PLUGINS\b/u.test(nextSource)) {
-        nextSource += EDITOR_PLUGINS_CONST_SECTION;
+    for (const section of INVENTORY_SECTIONS) {
+        if (section.interface &&
+            !hasExportedInterface(nextSource, section.interface.name)) {
+            nextSource += section.interface.section;
+        }
+        if (section.value && !hasExportedConst(nextSource, section.value.name)) {
+            nextSource += section.value.section;
+        }
     }
     return `${nextSource}\n`;
 }
+function hasExportedInterface(source, interfaceName) {
+    return new RegExp(`export\\s+interface\\s+${escapeRegex(interfaceName)}\\b`, "u").test(source);
+}
+function hasExportedConst(source, constName) {
+    return new RegExp(`export\\s+const\\s+${escapeRegex(constName)}\\b`, "u").test(source);
+}
 function appendEntriesAtMarker(source, marker, entries) {
     if (entries.length === 0) {
         return source;

package/dist/runtime/workspace-project.d.ts

@@ -1,4 +1,4 @@
-import type { PackageManagerId } from "./package-managers.js";
+import { type PackageManagerId } from "./package-managers.js";
 export declare const WORKSPACE_TEMPLATE_PACKAGE = "@wp-typia/create-workspace-template";
 export interface WorkspacePackageJson {
     author?: string;

package/dist/runtime/workspace-project.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { parsePackageManagerField, } from "./package-managers.js";
 export const WORKSPACE_TEMPLATE_PACKAGE = "@wp-typia/create-workspace-template";
 function hasNonEmptyString(value) {
     return typeof value === "string" && value.trim().length > 0;
@@ -81,16 +82,7 @@ export function getInvalidWorkspaceProjectReason(startDir) {
  * field is missing or unsupported.
  */
 export function parseWorkspacePackageManagerId(packageManagerField) {
-    const packageManagerId = packageManagerField?.split("@", 1)[0];
-    switch (packageManagerId) {
-        case "bun":
-        case "npm":
-        case "pnpm":
-        case "yarn":
-            return packageManagerId;
-        default:
-            return "npm";
-    }
+    return parsePackageManagerField(packageManagerField) ?? "npm";
 }
 /**
  * Try to resolve the nearest official wp-typia workspace from `startDir`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wp-typia/project-tools",
-  "version": "0.22.3",
+  "version": "0.22.4",
   "description": "Project orchestration and programmatic tooling for wp-typia",
   "packageManager": "bun@1.3.11",
   "type": "module",
@@ -147,7 +147,7 @@
   "dependencies": {
     "@wp-typia/api-client": "^0.4.5",
     "@wp-typia/block-runtime": "^0.5.0",
-    "@wp-typia/rest": "^0.3.12",
+    "@wp-typia/rest": "^0.3.13",
     "@wp-typia/block-types": "^0.2.4",
     "mustache": "^4.2.0",
     "npm-package-arg": "^13.0.0",