@breadstone/archipel-mcp 0.0.20 → 0.0.22

package/src/generators/mappingPatternGenerator.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAPPING_PATTERN_WITH_CONTEXT = MAPPING_PATTERN_WITH_CONTEXT;
+/**
+ * Generates a full mapping example (input interface, key, profile, module registration,
+ * controller usage) for a given entity and its target response class.
+ */
+function MAPPING_PATTERN_WITH_CONTEXT(entityName, fields, responseName) {
+    return `
+## Example: Mapping for "${entityName}" → "${responseName}"
+
+Given an entity \`${entityName}\` with fields: ${fields.map((f) => `\`${f}\``).join(', ')}
+
+### 1. Input Interface
+
+\`\`\`typescript
+// models/mapping-inputs/I${entityName}MappingInput.ts
+
+export interface I${entityName}MappingInput {
+${fields.map((f) => `  readonly ${f}: ${inferMappingFieldType(f)};`).join('\n')}
+}
+\`\`\`
+
+### 2. Mapping Key
+
+\`\`\`typescript
+// constants/MappingKeys.ts
+import { createMappingKey } from '@breadstone/archipel-platform-mapping';
+import { I${entityName}MappingInput } from '../models/mapping-inputs/I${entityName}MappingInput';
+import { ${responseName} } from '../dtos/${responseName}';
+
+export const ${toConstantCase(entityName)}_MAPPING_KEY = createMappingKey<I${entityName}MappingInput, ${responseName}>('${toDotNotation(entityName)}');
+\`\`\`
+
+### 3. Mapping Profile
+
+\`\`\`typescript
+// mappers/${entityName}MappingProfile.ts
+import { MappingProfileBase, IMappingBuilder } from '@breadstone/archipel-platform-mapping';
+import { ${toConstantCase(entityName)}_MAPPING_KEY } from '../constants/MappingKeys';
+import { I${entityName}MappingInput } from '../models/mapping-inputs/I${entityName}MappingInput';
+import { ${responseName} } from '../dtos/${responseName}';
+
+export class ${entityName}MappingProfile extends MappingProfileBase {
+
+  // #region Methods
+
+  public configure(builder: IMappingBuilder): void {
+    builder.createKeyedMap(${toConstantCase(entityName)}_MAPPING_KEY, (input: I${entityName}MappingInput) => {
+      const response = new ${responseName}();
+${fields.map((f) => `      response.${f} = input.${f};`).join('\n')}
+
+      return response;
+    });
+  }
+
+  // #endregion
+
+}
+\`\`\`
+
+### 4. Module Registration
+
+\`\`\`typescript
+import { MappingModule } from '@breadstone/archipel-platform-mapping';
+import { ${entityName}MappingProfile } from './mappers/${entityName}MappingProfile';
+
+@Module({
+  imports: [
+    MappingModule.withProfiles([${entityName}MappingProfile]),
+  ],
+})
+export class ${entityName}Module {}
+\`\`\`
+
+### 5. Controller Usage
+
+\`\`\`typescript
+// In a controller method:
+const entity = await this._${lowerFirst(entityName)}Service.findById(id);
+const response = this._mappingService.map(${toConstantCase(entityName)}_MAPPING_KEY, entity);
+\`\`\`
+`;
+}
+function inferMappingFieldType(fieldName) {
+    if (fieldName === 'id')
+        return 'string';
+    if (fieldName.endsWith('Id'))
+        return 'string';
+    if (fieldName.endsWith('At') || fieldName === 'createdAt' || fieldName === 'updatedAt')
+        return 'Date';
+    if (fieldName.startsWith('is') || fieldName.startsWith('has'))
+        return 'boolean';
+    if (fieldName === 'count' || fieldName === 'quantity' || fieldName === 'amount' || fieldName === 'price')
+        return 'number';
+    return 'string';
+}
+function toConstantCase(name) {
+    return name.replace(/([a-z])([A-Z])/g, '$1_$2').toUpperCase();
+}
+function toDotNotation(name) {
+    return name.replace(/([a-z])([A-Z])/g, '$1.$2').toLowerCase();
+}
+function lowerFirst(str) {
+    return str.charAt(0).toLowerCase() + str.slice(1);
+}
+//# sourceMappingURL=mappingPatternGenerator.js.map

package/src/generators/modulePatternGenerator.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generates a dynamic NestJS module example with ports, options interface,
+ * module class, and consumer registration for the given module and port names.
+ */
+export declare function MODULE_PATTERN_WITH_CONTEXT(moduleName: string, ports: string[]): string;

package/src/generators/modulePatternGenerator.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODULE_PATTERN_WITH_CONTEXT = MODULE_PATTERN_WITH_CONTEXT;
+/**
+ * Generates a dynamic NestJS module example with ports, options interface,
+ * module class, and consumer registration for the given module and port names.
+ */
+function MODULE_PATTERN_WITH_CONTEXT(moduleName, ports) {
+    return `
+## Example: Dynamic Module "${moduleName}"
+
+With ports: ${ports.map((p) => `\`${p}\``).join(', ')}
+
+### Port Definitions
+
+${ports
+        .map((port) => `\`\`\`typescript
+// contracts/${port}.ts
+
+export abstract class ${port} {
+
+  // Define abstract methods for the port contract
+  public abstract execute(/* args */): Promise<void>;
+
+}
+\`\`\``)
+        .join('\n\n')}
+
+### Options Interface
+
+\`\`\`typescript
+// interfaces/I${moduleName}Options.ts
+import { Type } from '@nestjs/common';
+${ports.map((port) => `import { ${port} } from '../contracts/${port}';`).join('\n')}
+
+export interface I${moduleName}Options {
+${ports.map((port) => `  ${lowerFirstChar(port)}: Type<${port}>;`).join('\n')}
+  isGlobal?: boolean;
+}
+\`\`\`
+
+### Module Class
+
+\`\`\`typescript
+// ${moduleName}.ts
+import { ConfigModule } from '@breadstone/archipel-platform-core';
+import { type DynamicModule, Module, type Type } from '@nestjs/common';
+import { I${moduleName}Options } from './interfaces/I${moduleName}Options';
+${ports.map((port) => `import { ${port} } from './contracts/${port}';`).join('\n')}
+
+@Module({})
+export class ${moduleName} {
+
+  public static register(options: I${moduleName}Options): DynamicModule {
+    const portProviders = [
+${ports.map((port) => `      { provide: ${port}, useClass: options.${lowerFirstChar(port)} },`).join('\n')}
+    ];
+
+    return {
+      global: options.isGlobal ?? false,
+      module: ${moduleName},
+      imports: [
+        ConfigModule.register('${toKebabCase(moduleName)}', PLATFORM_${toUpperSnakeCase(moduleName)}_CONFIG_ENTRIES),
+      ],
+      providers: [
+        ...portProviders,
+        // Add services, guards, interceptors here
+      ],
+      exports: [
+        // Export public services, guards, interceptors
+      ],
+    };
+  }
+
+}
+\`\`\`
+
+### Consumer Usage
+
+\`\`\`typescript
+@Module({
+  imports: [
+    ${moduleName}.register({
+${ports.map((port) => `      ${lowerFirstChar(port)}: My${port}Adapter,`).join('\n')}
+    }),
+  ],
+})
+export class AppModule {}
+\`\`\`
+`;
+}
+function lowerFirstChar(str) {
+    return str.charAt(0).toLowerCase() + str.slice(1);
+}
+function toKebabCase(name) {
+    return name
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .toLowerCase()
+        .replace(/module$/, '');
+}
+function toUpperSnakeCase(name) {
+    return name
+        .replace(/([a-z])([A-Z])/g, '$1_$2')
+        .toUpperCase()
+        .replace(/MODULE$/, '');
+}
+//# sourceMappingURL=modulePatternGenerator.js.map

package/src/generators/queryPatternGenerator.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generates model-specific query factory examples based on a Prisma model name and its fields.
+ */
+export declare function QUERY_PATTERN_WITH_MODEL(modelName: string, fields: string[]): string;

package/src/generators/queryPatternGenerator.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QUERY_PATTERN_WITH_MODEL = QUERY_PATTERN_WITH_MODEL;
+/**
+ * Generates model-specific query factory examples based on a Prisma model name and its fields.
+ */
+function QUERY_PATTERN_WITH_MODEL(modelName, fields) {
+    return `
+## Example: Queries for "${modelName}"
+
+Given a Prisma model \`${modelName}\` with fields: ${fields.map((f) => `\`${f}\``).join(', ')}
+
+### findFirst query
+\`\`\`typescript
+import { Prisma } from '@prisma/client';
+import { query } from '@breadstone/archipel-platform-database';
+
+export function find${modelName}ByIdQuery(id: string) {
+  return query<Prisma.${modelName}Delegate, { ${fields.map((f) => `${f}: ${inferFieldType(f)}`).join('; ')} } | null>(
+    'find${modelName}ById',
+    (model) =>
+      model.findFirst({
+        where: { id },
+        select: { ${fields.map((f) => `${f}: true`).join(', ')} },
+      }),
+  );
+}
+\`\`\`
+
+### findMany query
+\`\`\`typescript
+export function findAll${modelName}sQuery(skip = 0, take = 20) {
+  return query<Prisma.${modelName}Delegate, Array<{ ${fields.map((f) => `${f}: ${inferFieldType(f)}`).join('; ')} }>>(
+    'findAll${modelName}s',
+    (model) =>
+      model.findMany({
+        skip,
+        take,
+        select: { ${fields.map((f) => `${f}: true`).join(', ')} },
+        orderBy: { ${fields.includes('createdAt') ? 'createdAt' : fields[0]}: 'desc' },
+      }),
+  );
+}
+\`\`\`
+
+### count query
+\`\`\`typescript
+export function count${modelName}sQuery() {
+  return query<Prisma.${modelName}Delegate, number>(
+    'count${modelName}s',
+    (model) => model.count(),
+  );
+}
+\`\`\`
+
+### Service usage
+\`\`\`typescript
+// In a service method:
+const item = await this._${lowerFirst(modelName)}Repository.execute(find${modelName}ByIdQuery(id));
+const items = await this._${lowerFirst(modelName)}Repository.execute(findAll${modelName}sQuery(0, 50));
+const total = await this._${lowerFirst(modelName)}Repository.execute(count${modelName}sQuery());
+\`\`\`
+`;
+}
+function inferFieldType(fieldName) {
+    if (fieldName === 'id')
+        return 'string';
+    if (fieldName.endsWith('Id'))
+        return 'string';
+    if (fieldName.endsWith('At') || fieldName === 'createdAt' || fieldName === 'updatedAt')
+        return 'Date';
+    if (fieldName.startsWith('is') || fieldName.startsWith('has'))
+        return 'boolean';
+    if (fieldName === 'count' || fieldName === 'quantity' || fieldName === 'amount' || fieldName === 'order')
+        return 'number';
+    if (fieldName === 'email' || fieldName === 'name' || fieldName === 'title' || fieldName === 'description')
+        return 'string';
+    return 'unknown';
+}
+function lowerFirst(str) {
+    return str.charAt(0).toLowerCase() + str.slice(1);
+}
+//# sourceMappingURL=queryPatternGenerator.js.map

package/src/generators/repositoryPatternGenerator.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generates a full repository class, entity interface, query factories, module
+ * registration, and service usage example for a given Prisma model.
+ */
+export declare function REPOSITORY_PATTERN_WITH_MODEL(modelName: string, fields: string[]): string;

package/src/generators/repositoryPatternGenerator.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REPOSITORY_PATTERN_WITH_MODEL = REPOSITORY_PATTERN_WITH_MODEL;
+/**
+ * Generates a full repository class, entity interface, query factories, module
+ * registration, and service usage example for a given Prisma model.
+ */
+function REPOSITORY_PATTERN_WITH_MODEL(modelName, fields) {
+    return `
+## Example: Repository for "${modelName}"
+
+Given a Prisma model \`${modelName}\` with fields: ${fields.map((f) => `\`${f}\``).join(', ')}
+
+### Repository Class
+
+\`\`\`typescript
+// repositories/${modelName}Repository.ts
+import { Injectable } from '@nestjs/common';
+import { Prisma } from '@prisma/client';
+import {
+  DatabaseService,
+  DelegateArgs,
+  DelegateReturnTypes,
+  RepositoryBase,
+} from '@breadstone/archipel-platform-database';
+import { I${modelName}Entity } from '../models/entities/I${modelName}Entity';
+
+@Injectable()
+export class ${modelName}Repository extends RepositoryBase<
+  Prisma.${modelName}Delegate,
+  DelegateArgs<Prisma.${modelName}Delegate>,
+  DelegateReturnTypes<Prisma.${modelName}Delegate>,
+  I${modelName}Entity
+> {
+
+  // #region Ctor
+
+  public constructor(db: DatabaseService) {
+    super(db, db.client.${lowerFirst(modelName)});
+  }
+
+  // #endregion
+
+}
+\`\`\`
+
+### Entity Interface
+
+\`\`\`typescript
+// models/entities/I${modelName}Entity.ts
+export interface I${modelName}Entity {
+${fields.map((f) => `  readonly ${f}: ${inferFieldType(f)};`).join('\n')}
+}
+\`\`\`
+
+### Query Factories
+
+\`\`\`typescript
+// queries/find${modelName}ByIdQuery.ts
+import { Prisma } from '@prisma/client';
+import { query } from '@breadstone/archipel-platform-database';
+import { I${modelName}Entity } from '../models/entities/I${modelName}Entity';
+
+export function find${modelName}ByIdQuery(id: string) {
+  return query<Prisma.${modelName}Delegate, I${modelName}Entity | null>(
+    'find${modelName}ById',
+    (model) => model.findFirst({
+      where: { id },
+      select: { ${fields.map((f) => `${f}: true`).join(', ')} },
+    }),
+  );
+}
+
+export function findAll${modelName}sQuery(skip = 0, take = 20) {
+  return query<Prisma.${modelName}Delegate, I${modelName}Entity[]>(
+    'findAll${modelName}s',
+    (model) => model.findMany({
+      skip,
+      take,
+      select: { ${fields.map((f) => `${f}: true`).join(', ')} },
+      orderBy: { ${fields.includes('createdAt') ? 'createdAt' : fields[0]}: 'desc' },
+    }),
+  );
+}
+
+export function count${modelName}sQuery() {
+  return query<Prisma.${modelName}Delegate, number>(
+    'count${modelName}s',
+    (model) => model.count(),
+  );
+}
+\`\`\`
+
+### Module Registration
+
+\`\`\`typescript
+import { DatabaseModule } from '@breadstone/archipel-platform-database';
+import { ${modelName}Repository } from './repositories/${modelName}Repository';
+import { ${modelName}Service } from './services/${modelName}Service';
+
+@Module({
+  imports: [DatabaseModule.register()],
+  providers: [${modelName}Repository, ${modelName}Service],
+  exports: [${modelName}Service],
+})
+export class ${modelName}Module {}
+\`\`\`
+
+### Service Usage
+
+\`\`\`typescript
+@Injectable()
+export class ${modelName}Service {
+
+  // #region Fields
+
+  private readonly _${lowerFirst(modelName)}Repository: ${modelName}Repository;
+
+  // #endregion
+
+  // #region Ctor
+
+  public constructor(${lowerFirst(modelName)}Repository: ${modelName}Repository) {
+    this._${lowerFirst(modelName)}Repository = ${lowerFirst(modelName)}Repository;
+  }
+
+  // #endregion
+
+  // #region Methods
+
+  public async findById(id: string): Promise<I${modelName}Entity | null> {
+    return this._${lowerFirst(modelName)}Repository.execute(find${modelName}ByIdQuery(id));
+  }
+
+  public async findAll(skip = 0, take = 20): Promise<I${modelName}Entity[]> {
+    return this._${lowerFirst(modelName)}Repository.execute(findAll${modelName}sQuery(skip, take));
+  }
+
+  public async count(): Promise<number> {
+    return this._${lowerFirst(modelName)}Repository.execute(count${modelName}sQuery());
+  }
+
+  // #endregion
+
+}
+\`\`\`
+`;
+}
+function inferFieldType(fieldName) {
+    if (fieldName === 'id')
+        return 'string';
+    if (fieldName.endsWith('Id'))
+        return 'string';
+    if (fieldName.endsWith('At') || fieldName === 'createdAt' || fieldName === 'updatedAt')
+        return 'Date';
+    if (fieldName.startsWith('is') || fieldName.startsWith('has'))
+        return 'boolean';
+    if (fieldName === 'count' || fieldName === 'quantity' || fieldName === 'amount' || fieldName === 'price')
+        return 'number';
+    return 'string';
+}
+function lowerFirst(str) {
+    return str.charAt(0).toLowerCase() + str.slice(1);
+}
+//# sourceMappingURL=repositoryPatternGenerator.js.map

package/src/main.js

@@ -5,6 +5,7 @@ const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const DocsLoader_1 = require("./DocsLoader");
 const GuidesLoader_1 = require("./GuidesLoader");
+const PatternsLoader_1 = require("./PatternsLoader");
 const registerGetConfigPatternTool_1 = require("./tools/registerGetConfigPatternTool");
 const registerGetDtoPatternTool_1 = require("./tools/registerGetDtoPatternTool");
 const registerGetErrorHandlingPatternTool_1 = require("./tools/registerGetErrorHandlingPatternTool");
@@ -30,6 +31,8 @@ async function main() {
     docsLoader.load();
     const guidesLoader = new GuidesLoader_1.GuidesLoader();
     guidesLoader.load();
+    const patternsLoader = new PatternsLoader_1.PatternsLoader();
+    patternsLoader.load();
     const server = new mcp_js_1.McpServer({
         name: SERVER_NAME,
         description: 'MCP server for Archipel platform documentation, guides, and knowledge base.',
@@ -37,21 +40,24 @@ async function main() {
         websiteUrl: 'https://archipel.breadstone.de/',
         version: SERVER_VERSION,
     });
+    // docs tools
     (0, registerListPackagesTool_1.registerListPackagesTool)(server, docsLoader);
     (0, registerGetPackageDocTool_1.registerGetPackageDocTool)(server, docsLoader);
     (0, registerSearchDocsTool_1.registerSearchDocsTool)(server, docsLoader);
+    // guides tools
     (0, registerListGuidesTool_1.registerListGuidesTool)(server, guidesLoader);
     (0, registerGetGuideTool_1.registerGetGuideTool)(server, guidesLoader);
     (0, registerSearchGuidesTool_1.registerSearchGuidesTool)(server, guidesLoader);
-    (0, registerGetQueryPatternTool_1.registerGetQueryPatternTool)(server);
-    (0, registerGetRepositoryPatternTool_1.registerGetRepositoryPatternTool)(server);
-    (0, registerGetMappingPatternTool_1.registerGetMappingPatternTool)(server);
-    (0, registerGetModulePatternTool_1.registerGetModulePatternTool)(server);
-    (0, registerGetErrorHandlingPatternTool_1.registerGetErrorHandlingPatternTool)(server);
-    (0, registerGetConfigPatternTool_1.registerGetConfigPatternTool)(server);
-    (0, registerGetGuardPatternTool_1.registerGetGuardPatternTool)(server);
-    (0, registerGetDtoPatternTool_1.registerGetDtoPatternTool)(server);
-    (0, registerGetTestingPatternTool_1.registerGetTestingPatternTool)(server);
+    // pattern tools
+    (0, registerGetQueryPatternTool_1.registerGetQueryPatternTool)(server, patternsLoader);
+    (0, registerGetRepositoryPatternTool_1.registerGetRepositoryPatternTool)(server, patternsLoader);
+    (0, registerGetMappingPatternTool_1.registerGetMappingPatternTool)(server, patternsLoader);
+    (0, registerGetModulePatternTool_1.registerGetModulePatternTool)(server, patternsLoader);
+    (0, registerGetErrorHandlingPatternTool_1.registerGetErrorHandlingPatternTool)(server, patternsLoader);
+    (0, registerGetConfigPatternTool_1.registerGetConfigPatternTool)(server, patternsLoader);
+    (0, registerGetGuardPatternTool_1.registerGetGuardPatternTool)(server, patternsLoader);
+    (0, registerGetDtoPatternTool_1.registerGetDtoPatternTool)(server, patternsLoader);
+    (0, registerGetTestingPatternTool_1.registerGetTestingPatternTool)(server, patternsLoader);
     const transport = new stdio_js_1.StdioServerTransport();
     await server.connect(transport);
     process.stderr.write(`[${SERVER_NAME}] Server running on stdio\n`);

package/src/models/IPatternDoc.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Describes a loaded pattern documentation entry.
+ */
+export interface IPatternDoc {
+    /** File name without extension (e.g. "config-pattern"). */
+    readonly name: string;
+    /** Human-readable title from frontmatter. */
+    readonly title: string;
+    /** Short description from frontmatter. */
+    readonly description: string;
+    /** Sort order from frontmatter. */
+    readonly order: number;
+    /** Markdown body (without frontmatter). */
+    readonly content: string;
+}

package/src/models/IPatternDoc.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IPatternDoc.js.map

package/src/tools/registerGetConfigPatternTool.d.ts

@@ -1,5 +1,6 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { PatternsLoader } from '../PatternsLoader';
 /**
  * Registers the get-config-pattern tool on the MCP server.
  */
-export declare function registerGetConfigPatternTool(server: McpServer): void;
+export declare function registerGetConfigPatternTool(server: McpServer, patternsLoader: PatternsLoader): void;

package/src/tools/registerGetConfigPatternTool.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerGetConfigPatternTool = registerGetConfigPatternTool;
-const configPattern_1 = require("../knowledge/configPattern");
 /**
  * Registers the get-config-pattern tool on the MCP server.
  */
-function registerGetConfigPatternTool(server) {
+function registerGetConfigPatternTool(server, patternsLoader) {
     server.tool('get-config-pattern', 'Returns the Archipel configuration pattern — typed config keys (createConfigKey), ConfigRegistry, ConfigService, env.ts conventions, and ConfigModule integration.', {}, async () => {
+        const pattern = patternsLoader.patterns.get('config-pattern');
+        const text = pattern?.content ?? 'Config pattern documentation not available.';
         return {
-            content: [{ type: 'text', text: configPattern_1.CONFIG_PATTERN_KNOWLEDGE }],
+            content: [{ type: 'text', text }],
         };
     });
 }

package/src/tools/registerGetDtoPatternTool.d.ts

@@ -1,5 +1,6 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { PatternsLoader } from '../PatternsLoader';
 /**
  * Registers the get-dto-pattern tool on the MCP server.
  */
-export declare function registerGetDtoPatternTool(server: McpServer): void;
+export declare function registerGetDtoPatternTool(server: McpServer, patternsLoader: PatternsLoader): void;

package/src/tools/registerGetDtoPatternTool.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerGetDtoPatternTool = registerGetDtoPatternTool;
-const dtoPattern_1 = require("../knowledge/dtoPattern");
 /**
  * Registers the get-dto-pattern tool on the MCP server.
  */
-function registerGetDtoPatternTool(server) {
+function registerGetDtoPatternTool(server, patternsLoader) {
     server.tool('get-dto-pattern', 'Returns the Archipel DTO & validation pattern — Request/Response DTOs, class-validator decorators, cross-field validation, query parameter DTOs, OpenAPI integration, and naming conventions.', {}, async () => {
+        const pattern = patternsLoader.patterns.get('dto-pattern');
+        const text = pattern?.content ?? 'DTO pattern documentation not available.';
         return {
-            content: [{ type: 'text', text: dtoPattern_1.DTO_PATTERN_KNOWLEDGE }],
+            content: [{ type: 'text', text }],
         };
     });
 }

package/src/tools/registerGetErrorHandlingPatternTool.d.ts

@@ -1,5 +1,6 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { PatternsLoader } from '../PatternsLoader';
 /**
  * Registers the get-error-handling-pattern tool on the MCP server.
  */
-export declare function registerGetErrorHandlingPatternTool(server: McpServer): void;
+export declare function registerGetErrorHandlingPatternTool(server: McpServer, patternsLoader: PatternsLoader): void;

package/src/tools/registerGetErrorHandlingPatternTool.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerGetErrorHandlingPatternTool = registerGetErrorHandlingPatternTool;
-const errorHandlingPattern_1 = require("../knowledge/errorHandlingPattern");
 /**
  * Registers the get-error-handling-pattern tool on the MCP server.
  */
-function registerGetErrorHandlingPatternTool(server) {
+function registerGetErrorHandlingPatternTool(server, patternsLoader) {
     server.tool('get-error-handling-pattern', 'Returns the Archipel error handling pattern — domain errors, RepositoryError, exception filters, and structured error response envelopes.', {}, async () => {
+        const pattern = patternsLoader.patterns.get('error-handling-pattern');
+        const text = pattern?.content ?? 'Error handling pattern documentation not available.';
         return {
-            content: [{ type: 'text', text: errorHandlingPattern_1.ERROR_HANDLING_PATTERN_KNOWLEDGE }],
+            content: [{ type: 'text', text }],
         };
     });
 }

package/src/tools/registerGetGuardPatternTool.d.ts

@@ -1,5 +1,6 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { PatternsLoader } from '../PatternsLoader';
 /**
  * Registers the get-guard-pattern tool on the MCP server.
  */
-export declare function registerGetGuardPatternTool(server: McpServer): void;
+export declare function registerGetGuardPatternTool(server: McpServer, patternsLoader: PatternsLoader): void;

package/src/tools/registerGetGuardPatternTool.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerGetGuardPatternTool = registerGetGuardPatternTool;
-const guardPattern_1 = require("../knowledge/guardPattern");
 /**
  * Registers the get-guard-pattern tool on the MCP server.
  */
-function registerGetGuardPatternTool(server) {
+function registerGetGuardPatternTool(server, patternsLoader) {
     server.tool('get-guard-pattern', 'Returns the Archipel guard & interceptor pattern — metadata decorators, FeatureGuard, RolesGuard, FeatureUsageInterceptor, and the full decorator-guard-interceptor trio.', {}, async () => {
+        const pattern = patternsLoader.patterns.get('guard-pattern');
+        const text = pattern?.content ?? 'Guard pattern documentation not available.';
         return {
-            content: [{ type: 'text', text: guardPattern_1.GUARD_PATTERN_KNOWLEDGE }],
+            content: [{ type: 'text', text }],
         };
     });
 }