@toolfactory.dev/core 1.0.0-rc

package/out/codegen/document-validation.js

@@ -0,0 +1,76 @@
+import chalk from 'chalk';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { URI } from 'langium';
+export function collectLangiumDocumentErrors(document) {
+    const errors = [];
+    for (const parserError of document.parseResult?.parserErrors ?? []) {
+        errors.push({
+            severity: 1,
+            message: parserError.message,
+            range: {
+                start: { line: 0, character: 0 },
+                end: { line: 0, character: 0 }
+            }
+        });
+    }
+    for (const diagnostic of document.diagnostics ?? []) {
+        if (diagnostic.severity === 1) {
+            errors.push({
+                severity: diagnostic.severity,
+                message: diagnostic.message,
+                range: {
+                    start: {
+                        line: diagnostic.range.start.line,
+                        character: diagnostic.range.start.character ?? 0
+                    },
+                    end: {
+                        line: diagnostic.range.end?.line ?? diagnostic.range.start.line,
+                        character: diagnostic.range.end?.character ?? diagnostic.range.start.character ?? 0
+                    }
+                }
+            });
+        }
+    }
+    return errors;
+}
+export function printDocumentValidationErrors(document, errors) {
+    for (const diagnostic of errors) {
+        const hasRange = diagnostic.range.start.line > 0 ||
+            diagnostic.range.start.character > 0 ||
+            diagnostic.range.end.character > diagnostic.range.start.character;
+        const location = hasRange ? `line ${diagnostic.range.start.line + 1}: ` : '';
+        const snippet = hasRange && diagnostic.range.end.character > diagnostic.range.start.character
+            ? ` [${document.textDocument.getText(diagnostic.range)}]`
+            : '';
+        console.error(chalk.red(`${location}${diagnostic.message}${snippet}`));
+    }
+}
+function reportValidationErrorsAndExit(fileName, document, errors) {
+    console.error(chalk.red(`Cannot generate — fix ${errors.length} validation error(s) in ${path.basename(fileName)} first:`));
+    printDocumentValidationErrors(document, errors);
+    process.exit(1);
+    throw new Error('unreachable');
+}
+export async function assertDocumentValidForGenerate(fileName, services, options = {}) {
+    const extensions = services.LanguageMetaData.fileExtensions;
+    if (!extensions.includes(path.extname(fileName))) {
+        console.error(chalk.yellow(`Please choose a file with one of these extensions: ${extensions}.`));
+        process.exit(1);
+    }
+    if (!fs.existsSync(fileName)) {
+        console.error(chalk.red(`File ${fileName} does not exist.`));
+        process.exit(1);
+    }
+    options.beforeBuild?.();
+    const document = await services.shared.workspace.LangiumDocuments.getOrCreateDocument(URI.file(path.resolve(fileName)));
+    await services.shared.workspace.DocumentBuilder.build([document], { validation: true });
+    let errors = collectLangiumDocumentErrors(document);
+    if (options.extraErrors) {
+        errors = [...errors, ...(await options.extraErrors(document))];
+    }
+    if (errors.length > 0) {
+        reportValidationErrorsAndExit(fileName, document, errors);
+    }
+    return document;
+}

package/out/codegen/generated-layout.d.ts

@@ -0,0 +1,15 @@
+import type { McpHostProduct } from './mcp-host-product-runtime.js';
+/** Relative `.js` import spec from one `.ts` file to another. */
+export declare function relativeJsImportPath(fromTsPath: string, toTsPath: string): string;
+/** `generated/{hostProduct}/tools/{basename}-tools.ts` */
+export declare function resolveGeneratedToolsPath(projectRoot: string, hostProduct: McpHostProduct, dslBasename: string): string;
+/** Host product segment from a tools module path (`generated/api2ai/tools/…`). */
+export declare function resolveHostProductFromGeneratedToolsPath(toolsModuleTsPath: string): McpHostProduct;
+/** `generated/{product}/cli` for a tools module under `generated/{product}/tools/`. */
+export declare function resolveGeneratedCliDir(toolsModuleTsPath: string): string;
+export declare function resolveProjectRootFromGeneratedCliDir(cliDir: string): string;
+/** Fail when CLI destination path product segment does not match the generating CLI. */
+export declare function assertGeneratedToolsDestinationMatchesHostProduct(toolsModuleTsPath: string, hostProduct: McpHostProduct): void;
+/** Relative import from a generated cli/tools file to `src/utils/logging-adapter.ts`. */
+export declare function relativeImportToLoggingAdapter(fromGeneratedTsPath: string, projectRoot: string): string;
+export declare function loggingAdapterImportForCliFile(cliFileTsPath: string, projectRoot: string): string;

package/out/codegen/generated-layout.js

@@ -0,0 +1,53 @@
+import * as path from 'node:path';
+/** Relative `.js` import spec from one `.ts` file to another. */
+export function relativeJsImportPath(fromTsPath, toTsPath) {
+    let rel = path
+        .relative(path.dirname(path.resolve(fromTsPath)), path.resolve(toTsPath))
+        .split(path.sep)
+        .join('/');
+    if (!rel.startsWith('.')) {
+        rel = `./${rel}`;
+    }
+    return rel.replace(/\.ts$/, '.js');
+}
+/** `generated/{hostProduct}/tools/{basename}-tools.ts` */
+export function resolveGeneratedToolsPath(projectRoot, hostProduct, dslBasename) {
+    return path.join(projectRoot, 'generated', hostProduct, 'tools', `${dslBasename}-tools.ts`);
+}
+/** Host product segment from a tools module path (`generated/api2ai/tools/…`). */
+export function resolveHostProductFromGeneratedToolsPath(toolsModuleTsPath) {
+    const toolsDir = path.dirname(path.resolve(toolsModuleTsPath));
+    if (path.basename(toolsDir) !== 'tools') {
+        throw new Error(`Expected tools module under generated/<product>/tools/: ${toolsModuleTsPath}`);
+    }
+    const product = path.basename(path.dirname(toolsDir));
+    if (product !== 'api2ai' && product !== 'db2ai') {
+        throw new Error(`Unknown host product in tools path: ${product}`);
+    }
+    return product;
+}
+/** `generated/{product}/cli` for a tools module under `generated/{product}/tools/`. */
+export function resolveGeneratedCliDir(toolsModuleTsPath) {
+    const toolsDir = path.dirname(path.resolve(toolsModuleTsPath));
+    if (path.basename(toolsDir) !== 'tools') {
+        return path.join(toolsDir, 'cli');
+    }
+    return path.join(path.dirname(toolsDir), 'cli');
+}
+export function resolveProjectRootFromGeneratedCliDir(cliDir) {
+    return path.resolve(cliDir, '..', '..', '..');
+}
+/** Fail when CLI destination path product segment does not match the generating CLI. */
+export function assertGeneratedToolsDestinationMatchesHostProduct(toolsModuleTsPath, hostProduct) {
+    const actual = resolveHostProductFromGeneratedToolsPath(toolsModuleTsPath);
+    if (actual !== hostProduct) {
+        throw new Error(`[generate] destination "${toolsModuleTsPath}" is for host product "${actual}", but this CLI generates "${hostProduct}". Use generated/${hostProduct}/tools/<name>-tools.ts.`);
+    }
+}
+/** Relative import from a generated cli/tools file to `src/utils/logging-adapter.ts`. */
+export function relativeImportToLoggingAdapter(fromGeneratedTsPath, projectRoot) {
+    return relativeJsImportPath(fromGeneratedTsPath, path.join(projectRoot, 'src', 'utils', 'logging-adapter.ts'));
+}
+export function loggingAdapterImportForCliFile(cliFileTsPath, projectRoot) {
+    return relativeImportToLoggingAdapter(cliFileTsPath, projectRoot);
+}

package/out/codegen/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Shared codegen helpers.
+ * Extracted incrementally from api2ai/db2ai CLI code.
+ */
+export { authorizeExportName, prepareInputExportName } from './access-stubs.js';
+export * from './auth-module-names.js';
+export * from './auth-pipeline-render.js';
+export * from './auth-stub-bootstrap.js';
+export * from './logging-adapter-bootstrap.js';
+export * from './document-validation.js';
+export * from './langium-cli-types.js';
+export * from './generated-layout.js';
+export * from './project-bootstrap.js';
+export { renderStdioMcpServerSource } from './render-stdio-mcp-server.js';
+export { renderOAuthHttpMcpServerSource } from './render-oauth-http-mcp-server.js';
+export { renderPassthroughHttpMcpServerSource, renderPublicHttpMcpServerSource } from './render-http-mcp-server.js';
+export { renderMcpHostSharedSource } from './render-mcp-host-shared.js';
+export { writeGeneratedDemosTestSupport } from './write-demos-test-support.js';
+export { writeGeneratedScripts } from '../scripts/write-generated-scripts.js';
+export * from './zod-codegen.js';

package/out/codegen/index.js

@@ -0,0 +1,20 @@
+/**
+ * Shared codegen helpers.
+ * Extracted incrementally from api2ai/db2ai CLI code.
+ */
+export { authorizeExportName, prepareInputExportName } from './access-stubs.js';
+export * from './auth-module-names.js';
+export * from './auth-pipeline-render.js';
+export * from './auth-stub-bootstrap.js';
+export * from './logging-adapter-bootstrap.js';
+export * from './document-validation.js';
+export * from './langium-cli-types.js';
+export * from './generated-layout.js';
+export * from './project-bootstrap.js';
+export { renderStdioMcpServerSource } from './render-stdio-mcp-server.js';
+export { renderOAuthHttpMcpServerSource } from './render-oauth-http-mcp-server.js';
+export { renderPassthroughHttpMcpServerSource, renderPublicHttpMcpServerSource } from './render-http-mcp-server.js';
+export { renderMcpHostSharedSource } from './render-mcp-host-shared.js';
+export { writeGeneratedDemosTestSupport } from './write-demos-test-support.js';
+export { writeGeneratedScripts } from '../scripts/write-generated-scripts.js';
+export * from './zod-codegen.js';

package/out/codegen/langium-cli-types.d.ts

@@ -0,0 +1,45 @@
+export type CliLangiumDocument = {
+    uri?: {
+        toString(): string;
+    };
+    diagnostics?: Array<{
+        severity?: number;
+        message: string;
+        range: {
+            start: {
+                line: number;
+                character?: number;
+            };
+            end?: {
+                line: number;
+                character?: number;
+            };
+        };
+    }>;
+    textDocument: {
+        getText(range: unknown): string;
+    };
+    parseResult?: {
+        value?: unknown;
+        parserErrors?: Array<{
+            message: string;
+        }>;
+    };
+};
+export type CliLangiumServices = {
+    LanguageMetaData: {
+        fileExtensions: readonly string[];
+    };
+    shared: {
+        workspace: {
+            LangiumDocuments: {
+                getOrCreateDocument(uri: unknown): Promise<CliLangiumDocument>;
+            };
+            DocumentBuilder: {
+                build(documents: CliLangiumDocument[], options: {
+                    validation: boolean;
+                }): Promise<void>;
+            };
+        };
+    };
+};

package/out/codegen/langium-cli-types.js

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

package/out/codegen/logging-adapter-bootstrap.d.ts

@@ -0,0 +1,6 @@
+/** @deprecated Use relativeImportToLoggingAdapter — nested layout uses ../../../src/utils/logging-adapter.js */
+export declare const LOGGING_ADAPTER_IMPORT_FROM_GENERATED = "../../../src/utils/logging-adapter.js";
+export declare function resolveLoggingAdapterPath(projectRoot: string): string;
+export declare function renderLoggingAdapterStubContent(): string;
+export declare function ensureLoggingAdapterStubAtProjectRoot(projectRoot: string): string;
+export declare function ensureLoggingAdapterStubFromSource(source: string): string;

package/out/codegen/logging-adapter-bootstrap.js

@@ -0,0 +1,69 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { resolveBootstrapProjectRootFromSource } from './project-bootstrap.js';
+/** @deprecated Use relativeImportToLoggingAdapter — nested layout uses ../../../src/utils/logging-adapter.js */
+export const LOGGING_ADAPTER_IMPORT_FROM_GENERATED = '../../../src/utils/logging-adapter.js';
+export function resolveLoggingAdapterPath(projectRoot) {
+    return path.join(projectRoot, 'src', 'utils', 'logging-adapter.ts');
+}
+export function renderLoggingAdapterStubContent() {
+    return `/**
+ * Logging adapter (write-once — customize this file; re-generate does not overwrite).
+ * Default: stderr with ANSI colors. debug() only when process.env.LOG_LEVEL === 'debug'.
+ * Optional prefix: process.env.LOG_SERVICE_PREFIX (set by init / demo npm scripts).
+ */
+const GRAY = '\\x1b[90m';
+const RESET = '\\x1b[0m';
+const YELLOW = '\\x1b[33m';
+const RED = '\\x1b[31m';
+
+function servicePrefix(): string {
+    const raw = process.env.LOG_SERVICE_PREFIX?.trim();
+    return raw && raw.length > 0 ? '[' + raw + '] ' : '';
+}
+
+function formatLine(level: string, color: string, message: string, context?: object): string {
+    const suffix =
+        context !== undefined && Object.keys(context).length > 0 ? ' ' + JSON.stringify(context) : '';
+    return color + '[' + level + '] ' + servicePrefix() + message + suffix + RESET;
+}
+
+export class LoggingAdapter {
+    debug(message: string, context?: object): void {
+        if (process.env.LOG_LEVEL !== 'debug') {
+            return;
+        }
+        console.error(formatLine('debug', GRAY, message, context));
+    }
+
+    info(message: string, context?: object): void {
+        console.error(formatLine('info', RESET, message, context));
+    }
+
+    warn(message: string, context?: object): void {
+        console.error(formatLine('warn', YELLOW, message, context));
+    }
+
+    error(message: string, context?: object): void {
+        console.error(formatLine('error', RED, message, context));
+    }
+}
+
+export const loggingAdapter = new LoggingAdapter();
+`;
+}
+export function ensureLoggingAdapterStubAtProjectRoot(projectRoot) {
+    const utilsDir = path.join(projectRoot, 'src', 'utils');
+    const dest = resolveLoggingAdapterPath(projectRoot);
+    if (!fs.existsSync(utilsDir)) {
+        fs.mkdirSync(utilsDir, { recursive: true });
+    }
+    if (!fs.existsSync(dest)) {
+        fs.writeFileSync(dest, renderLoggingAdapterStubContent(), 'utf-8');
+    }
+    return dest;
+}
+export function ensureLoggingAdapterStubFromSource(source) {
+    const projectRoot = resolveBootstrapProjectRootFromSource(source);
+    return ensureLoggingAdapterStubAtProjectRoot(projectRoot);
+}

package/out/codegen/mcp-host-credential-validation.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Minimal relay credential helpers for generated MCP hosts.
+ * Cryptographic validation belongs in src/hooks (checked tools, verifyCredential).
+ */
+export declare function hostCredentialValidationRelaySource(): string;

package/out/codegen/mcp-host-credential-validation.js

@@ -0,0 +1,15 @@
+/**
+ * Minimal relay credential helpers for generated MCP hosts.
+ * Cryptographic validation belongs in src/hooks (checked tools, verifyCredential).
+ */
+export function hostCredentialValidationRelaySource() {
+    return `
+function resolveRelayHostCredential(
+    rawCredential: string | undefined
+): { credential?: string } {
+    if (!rawCredential?.trim()) {
+        return {};
+    }
+    return { credential: rawCredential.trim() };
+}`.trim();
+}

package/out/codegen/mcp-host-product-runtime.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Product-specific fragments for generated MCP host runtimes (api2ai vs db2ai).
+ */
+export type McpHostProduct = 'api2ai' | 'db2ai';
+/** Parameter name when GeneratedHostModule is required only for db2ai branches (api2ai → eslint _ prefix). */
+export declare function generatedModuleParam(product: McpHostProduct): string;
+export declare function hostCoreTypes(product: McpHostProduct): string;
+export declare function dbOnlyHelperFunctions(product: McpHostProduct): string;
+export declare function readGeneratedModuleTail(product: McpHostProduct): string;
+export declare function withDbConnectionHostContextFn(product: McpHostProduct): string;
+export declare function validateHostAtStartupFn(product: McpHostProduct): string;
+export declare function resolveHostContextForCallFn(product: McpHostProduct): string;
+export declare function validateHttpMcpHostAtStartupFn(product: McpHostProduct): string;
+export declare function resolveHostContextForHttpCallFn(product: McpHostProduct, httpMcpProfile: HttpMcpHostProfile): string;
+export type HttpMcpHostProfile = 'public' | 'passthrough';
+export declare function validateOAuthHttpHostAtStartupFn(product: McpHostProduct): string;
+export declare function resolveHostContextForOAuthSessionDbBranch(product: McpHostProduct): string;
+/** Skip baseUrl for db2ai modules that export connectionEnv (.db2ai SQL tools). */
+export declare function oauthHostContextBaseUrlFieldsFn(product: McpHostProduct): string;
+export declare function requireBaseUrlEnvArgvCheck(product: McpHostProduct, hostConfigExpr: string): string;
+/** @deprecated use validateHttpMcpHostAtStartupFn */
+export declare function validateStatelessHttpHostAtStartupFn(product: McpHostProduct): string;