@agiflowai/scaffold-mcp 1.0.21 → 1.0.23

package/dist/index.d.cts

@@ -1,8 +1,305 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { JsonSchema } from "@composio/json-schema-to-zod";
 import { z } from "zod";
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 
+//#region src/server/index.d.ts
+interface ServerOptions {
+  adminEnabled?: boolean;
+  isMonolith?: boolean;
+  promptAsSkill?: boolean;
+  fallbackTool?: string;
+  fallbackToolConfig?: Record<string, unknown>;
+}
+declare function createServer(options?: ServerOptions): Server;
+//#endregion
+//#region src/transports/types.d.ts
+/**
+ * Transport mode types
+ */
+declare enum TransportMode {
+  STDIO = "stdio",
+  HTTP = "http",
+  SSE = "sse",
+  CLI = "cli",
+}
+/**
+ * Transport configuration options
+ */
+interface TransportConfig {
+  mode: TransportMode;
+  port?: number;
+  host?: string;
+}
+/**
+ * Base interface for all transport handlers
+ */
+interface TransportHandler {
+  start(): Promise<void>;
+  stop(): Promise<void>;
+}
+/**
+ * HTTP transport specific types
+ */
+interface HttpTransportHandler$1 extends TransportHandler {
+  getPort(): number;
+  getHost(): string;
+}
+//#endregion
+//#region src/transports/stdio.d.ts
+/**
+ * Stdio transport handler for MCP server
+ * Used for command-line and direct integrations
+ */
+declare class StdioTransportHandler implements TransportHandler {
+  private server;
+  private transport;
+  constructor(server: Server);
+  start(): Promise<void>;
+  stop(): Promise<void>;
+}
+//#endregion
+//#region src/transports/sse.d.ts
+/**
+ * SSE (Server-Sent Events) transport handler
+ * Legacy transport for backwards compatibility (protocol version 2024-11-05)
+ * Uses separate endpoints: /sse for SSE stream (GET) and /messages for client messages (POST)
+ */
+declare class SseTransportHandler implements HttpTransportHandler$1 {
+  private serverFactory;
+  private app;
+  private server;
+  private sessionManager;
+  private config;
+  constructor(serverFactory: Server | (() => Server), config: TransportConfig);
+  private setupMiddleware;
+  private setupRoutes;
+  private handleSseConnection;
+  private handlePostMessage;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  getPort(): number;
+  getHost(): string;
+}
+//#endregion
+//#region src/transports/http.d.ts
+/**
+ * HTTP transport handler using Streamable HTTP (protocol version 2025-03-26)
+ * Provides stateful session management with resumability support
+ */
+declare class HttpTransportHandler implements HttpTransportHandler$1 {
+  private serverFactory;
+  private app;
+  private server;
+  private sessionManager;
+  private config;
+  constructor(serverFactory: Server | (() => Server), config: TransportConfig);
+  private setupMiddleware;
+  private setupRoutes;
+  private handlePostRequest;
+  private handleGetRequest;
+  private handleDeleteRequest;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  getPort(): number;
+  getHost(): string;
+}
+//#endregion
+//#region src/tools/types.d.ts
+/**
+ * Shared type definitions for MCP tools
+ */
+interface ToolDefinition {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: string;
+    properties: Record<string, any>;
+    required?: string[];
+    additionalProperties: boolean;
+  };
+}
+//#endregion
+//#region src/tools/GenerateBoilerplateFileTool.d.ts
+/**
+ * Tool to generate template files for boilerplates and features
+ */
+declare class GenerateBoilerplateFileTool {
+  static readonly TOOL_NAME = "generate-boilerplate-file";
+  private boilerplateGeneratorService;
+  private isMonolith;
+  constructor(templatesPath: string, isMonolith?: boolean);
+  /**
+   * Get the tool definition for MCP
+   */
+  getDefinition(): ToolDefinition;
+  /**
+   * Execute the tool
+   */
+  execute(args: {
+    templateName?: string;
+    filePath: string;
+    content?: string;
+    sourceFile?: string;
+    header?: string;
+  }): Promise<CallToolResult>;
+}
+//#endregion
+//#region src/tools/GenerateBoilerplateTool.d.ts
+/**
+ * Tool to generate a new boilerplate configuration in scaffold.yaml
+ */
+declare class GenerateBoilerplateTool {
+  static readonly TOOL_NAME = "generate-boilerplate";
+  private boilerplateGeneratorService;
+  private isMonolith;
+  constructor(templatesPath: string, isMonolith?: boolean);
+  /**
+   * Get the tool definition for MCP
+   */
+  getDefinition(): ToolDefinition;
+  /**
+   * Execute the tool
+   */
+  execute(args: {
+    templateName?: string;
+    boilerplateName: string;
+    description: string;
+    instruction?: string;
+    targetFolder?: string;
+    variables: Array<{
+      name: string;
+      description: string;
+      type: string;
+      required: boolean;
+      default?: any;
+    }>;
+    includes?: string[];
+  }): Promise<CallToolResult>;
+}
+//#endregion
+//#region src/tools/GenerateFeatureScaffoldTool.d.ts
+/**
+ * Tool to generate a new feature scaffold configuration in scaffold.yaml
+ */
+declare class GenerateFeatureScaffoldTool {
+  static readonly TOOL_NAME = "generate-feature-scaffold";
+  private scaffoldGeneratorService;
+  private isMonolith;
+  constructor(templatesPath: string, isMonolith?: boolean);
+  /**
+   * Get the tool definition for MCP
+   */
+  getDefinition(): ToolDefinition;
+  /**
+   * Execute the tool
+   */
+  execute(args: {
+    templateName?: string;
+    featureName: string;
+    description: string;
+    instruction?: string;
+    variables: Array<{
+      name: string;
+      description: string;
+      type: string;
+      required: boolean;
+      default?: any;
+    }>;
+    includes?: string[];
+    patterns?: string[];
+  }): Promise<CallToolResult>;
+}
+//#endregion
+//#region src/tools/ListBoilerplatesTool.d.ts
+declare class ListBoilerplatesTool {
+  static readonly TOOL_NAME = "list-boilerplates";
+  private boilerplateService;
+  private templateService;
+  private isMonolith;
+  constructor(templatesPath: string, isMonolith?: boolean);
+  /**
+   * Get the tool definition for MCP
+   */
+  getDefinition(): ToolDefinition;
+  /**
+   * Execute the tool
+   */
+  execute(args?: Record<string, any>): Promise<CallToolResult>;
+}
+//#endregion
+//#region src/tools/ListScaffoldingMethodsTool.d.ts
+declare class ListScaffoldingMethodsTool {
+  static readonly TOOL_NAME = "list-scaffolding-methods";
+  private fileSystemService;
+  private scaffoldingMethodsService;
+  private templateService;
+  private isMonolith;
+  constructor(templatesPath: string, isMonolith?: boolean);
+  /**
+   * Get the tool definition for MCP
+   */
+  getDefinition(): ToolDefinition;
+  /**
+   * Execute the tool
+   */
+  execute(args: Record<string, any>): Promise<CallToolResult>;
+}
+//#endregion
+//#region src/tools/UseBoilerplateTool.d.ts
+declare class UseBoilerplateTool {
+  static readonly TOOL_NAME = "use-boilerplate";
+  private boilerplateService;
+  private templateService;
+  private isMonolith;
+  constructor(templatesPath: string, isMonolith?: boolean);
+  /**
+   * Get the tool definition for MCP
+   */
+  getDefinition(): ToolDefinition;
+  /**
+   * Execute the tool
+   */
+  execute(args: Record<string, any>): Promise<CallToolResult>;
+}
+//#endregion
+//#region src/tools/UseScaffoldMethodTool.d.ts
+declare class UseScaffoldMethodTool {
+  static readonly TOOL_NAME = "use-scaffold-method";
+  private static readonly TEMP_LOG_DIR;
+  private fileSystemService;
+  private scaffoldingMethodsService;
+  private isMonolith;
+  constructor(templatesPath: string, isMonolith?: boolean);
+  /**
+   * Write scaffold execution info to temp log file for hook processing
+   */
+  private writePendingScaffoldLog;
+  /**
+   * Get the tool definition for MCP
+   */
+  getDefinition(): ToolDefinition;
+  /**
+   * Execute the tool
+   */
+  execute(args: Record<string, any>): Promise<CallToolResult>;
+}
+//#endregion
+//#region src/tools/WriteToFileTool.d.ts
+declare class WriteToFileTool {
+  static readonly TOOL_NAME = "write-to-file";
+  private fileSystemService;
+  constructor();
+  /**
+   * Get the tool definition for MCP
+   */
+  getDefinition(): ToolDefinition;
+  /**
+   * Execute the tool
+   */
+  execute(args: Record<string, any>): Promise<CallToolResult>;
+}
+//#endregion
 //#region src/services/BoilerplateGeneratorService.d.ts
 interface GenerateBoilerplateOptions {
   templateName: string;
@@ -493,434 +790,147 @@ interface ScaffoldMethod {
   generator?: string;
 }
 interface ListScaffoldingMethodsResult {
-  sourceTemplate: string;
-  templatePath: string;
-  methods: ScaffoldMethod[];
-  nextCursor?: string;
-  _meta?: {
-    total: number;
-    offset: number;
-    limit: number;
-  };
-}
-interface UseScaffoldMethodRequest {
-  projectPath: string;
-  scaffold_feature_name: string;
-  variables: Record<string, any>;
-  /** Optional session ID for logging scaffold execution */
-  sessionId?: string;
-  /** Optional scaffold-generated marker tag to inject into generated code files (default: @scaffold-generated) */
-  marker?: string;
-}
-declare class ScaffoldingMethodsService {
-  private fileSystem;
-  private templatesRootPath;
-  private templateService;
-  constructor(fileSystem: IFileSystemService, templatesRootPath: string);
-  listScaffoldingMethods(projectPath: string, cursor?: string): Promise<ListScaffoldingMethodsResult>;
-  /**
-   * Collects all scaffold methods for a template (no pagination)
-   * Used internally for lookups that need to search all methods
-   */
-  private collectAllMethodsByTemplate;
-  listScaffoldingMethodsByTemplate(templateName: string, cursor?: string): Promise<ListScaffoldingMethodsResult>;
-  /**
-   * Gets scaffolding methods with instructions rendered using provided variables
-   */
-  listScaffoldingMethodsWithVariables(projectPath: string, variables: Record<string, any>, cursor?: string): Promise<ListScaffoldingMethodsResult>;
-  /**
-   * Processes scaffold instruction with template service
-   */
-  processScaffoldInstruction(instruction: string, variables: Record<string, any>): string;
-  private findTemplatePath;
-  /**
-   * Resolves the project path, handling both monorepo and monolith cases
-   * Uses ProjectConfigResolver to find the correct workspace/project root
-   */
-  private resolveProjectPath;
-  /**
-   * Dynamically discovers all template directories
-   * Supports both flat structure (templates/nextjs-15) and nested structure (templates/apps/nextjs-15)
-   **/
-  private discoverTemplateDirs;
-  useScaffoldMethod(request: UseScaffoldMethodRequest): Promise<ScaffoldResult>;
-}
-//#endregion
-//#region src/services/ScaffoldProcessingService.d.ts
-/**
- * Shared service for common scaffolding operations like processing templates and tracking files
- */
-declare class ScaffoldProcessingService {
-  private fileSystem;
-  private variableReplacer;
-  constructor(fileSystem: IFileSystemService, variableReplacer: IVariableReplacementService);
-  /**
-   * Process a target path for variable replacement, handling both files and directories
-   */
-  processTargetForVariableReplacement(targetPath: string, variables: Record<string, any>): Promise<void>;
-  /**
-   * Track all created files, handling both single files and directories
-   */
-  trackCreatedFiles(targetPath: string, createdFiles: string[]): Promise<void>;
-  /**
-   * Track all existing files, handling both single files and directories
-   */
-  trackExistingFiles(targetPath: string, existingFiles: string[]): Promise<void>;
-  /**
-   * Copy source to target, then process templates and track files
-   * Now supports tracking existing files separately from created files
-   * Automatically handles .liquid template files by stripping the extension
-   */
-  copyAndProcess(sourcePath: string, targetPath: string, variables: Record<string, any>, createdFiles: string[], existingFiles?: string[]): Promise<void>;
-  /**
-   * Recursively collect all file paths in a directory for created files
-   */
-  private trackCreatedFilesRecursive;
-  /**
-   * Recursively collect all file paths in a directory for existing files
-   */
-  private trackExistingFilesRecursive;
-}
-//#endregion
-//#region src/services/ScaffoldService.d.ts
-declare class ScaffoldService implements IScaffoldService {
-  private fileSystem;
-  private scaffoldConfigLoader;
-  private variableReplacer;
-  static readonly DEFAULT_MARKER = "@scaffold-generated";
-  private readonly templatesRootPath;
-  private readonly processingService;
-  constructor(fileSystem: IFileSystemService, scaffoldConfigLoader: IScaffoldConfigLoader, variableReplacer: IVariableReplacementService, templatesRootPath?: string);
-  /**
-   * Scaffold a new project from a boilerplate template
-   */
-  useBoilerplate(options: BoilerplateOptions): Promise<ScaffoldResult>;
-  /**
-   * Scaffold a new feature into an existing project
-   */
-  useFeature(options: FeatureOptions): Promise<ScaffoldResult>;
-  /**
-   * Inject scaffold marker comment into generated code files.
-   * Prepends `// <marker>` to .ts/.tsx/.js/.jsx files that don't already have it.
-   * Fails silently — marker injection should never break scaffold output.
-   */
-  private injectScaffoldMarkers;
-  /**
-   * Common scaffolding processing logic shared by both useBoilerplate and useFeature
-   */
-  private processScaffold;
-}
-//#endregion
-//#region src/services/TemplateService.d.ts
-interface ITemplateService$1 {
-  renderString(template: string, variables: Record<string, any>): string;
-  containsTemplateVariables(content: string): boolean;
-}
-declare class TemplateService implements ITemplateService$1 {
-  private liquid;
-  constructor();
-  private toPascalCase;
-  private setupCustomFilters;
-  renderString(template: string, variables: Record<string, any>): string;
-  containsTemplateVariables(content: string): boolean;
-}
-//#endregion
-//#region src/services/VariableReplacementService.d.ts
-declare class VariableReplacementService implements IVariableReplacementService {
-  private fileSystem;
-  private templateService;
-  private readonly binaryExtensions;
-  constructor(fileSystem: IFileSystemService, templateService: ITemplateService);
-  processFilesForVariableReplacement(dirPath: string, variables: Record<string, any>): Promise<void>;
-  replaceVariablesInFile(filePath: string, variables: Record<string, any>): Promise<void>;
-  isBinaryFile(filePath: string): boolean;
-}
-//#endregion
-//#region src/tools/types.d.ts
-/**
- * Shared type definitions for MCP tools
- */
-interface ToolDefinition {
-  name: string;
-  description: string;
-  inputSchema: {
-    type: string;
-    properties: Record<string, any>;
-    required?: string[];
-    additionalProperties: boolean;
-  };
-}
-//#endregion
-//#region src/tools/GenerateBoilerplateFileTool.d.ts
-/**
- * Tool to generate template files for boilerplates and features
- */
-declare class GenerateBoilerplateFileTool {
-  static readonly TOOL_NAME = "generate-boilerplate-file";
-  private boilerplateGeneratorService;
-  private isMonolith;
-  constructor(templatesPath: string, isMonolith?: boolean);
-  /**
-   * Get the tool definition for MCP
-   */
-  getDefinition(): ToolDefinition;
-  /**
-   * Execute the tool
-   */
-  execute(args: {
-    templateName?: string;
-    filePath: string;
-    content?: string;
-    sourceFile?: string;
-    header?: string;
-  }): Promise<CallToolResult>;
-}
-//#endregion
-//#region src/tools/GenerateBoilerplateTool.d.ts
-/**
- * Tool to generate a new boilerplate configuration in scaffold.yaml
- */
-declare class GenerateBoilerplateTool {
-  static readonly TOOL_NAME = "generate-boilerplate";
-  private boilerplateGeneratorService;
-  private isMonolith;
-  constructor(templatesPath: string, isMonolith?: boolean);
-  /**
-   * Get the tool definition for MCP
-   */
-  getDefinition(): ToolDefinition;
-  /**
-   * Execute the tool
-   */
-  execute(args: {
-    templateName?: string;
-    boilerplateName: string;
-    description: string;
-    instruction?: string;
-    targetFolder?: string;
-    variables: Array<{
-      name: string;
-      description: string;
-      type: string;
-      required: boolean;
-      default?: any;
-    }>;
-    includes?: string[];
-  }): Promise<CallToolResult>;
-}
-//#endregion
-//#region src/tools/GenerateFeatureScaffoldTool.d.ts
-/**
- * Tool to generate a new feature scaffold configuration in scaffold.yaml
- */
-declare class GenerateFeatureScaffoldTool {
-  static readonly TOOL_NAME = "generate-feature-scaffold";
-  private scaffoldGeneratorService;
-  private isMonolith;
-  constructor(templatesPath: string, isMonolith?: boolean);
-  /**
-   * Get the tool definition for MCP
-   */
-  getDefinition(): ToolDefinition;
-  /**
-   * Execute the tool
-   */
-  execute(args: {
-    templateName?: string;
-    featureName: string;
-    description: string;
-    instruction?: string;
-    variables: Array<{
-      name: string;
-      description: string;
-      type: string;
-      required: boolean;
-      default?: any;
-    }>;
-    includes?: string[];
-    patterns?: string[];
-  }): Promise<CallToolResult>;
+  sourceTemplate: string;
+  templatePath: string;
+  methods: ScaffoldMethod[];
+  nextCursor?: string;
+  _meta?: {
+    total: number;
+    offset: number;
+    limit: number;
+  };
 }
-//#endregion
-//#region src/tools/ListBoilerplatesTool.d.ts
-declare class ListBoilerplatesTool {
-  static readonly TOOL_NAME = "list-boilerplates";
-  private boilerplateService;
+interface UseScaffoldMethodRequest {
+  projectPath: string;
+  scaffold_feature_name: string;
+  variables: Record<string, any>;
+  /** Optional session ID for logging scaffold execution */
+  sessionId?: string;
+  /** Optional scaffold-generated marker tag to inject into generated code files (default: @scaffold-generated) */
+  marker?: string;
+}
+declare class ScaffoldingMethodsService {
+  private fileSystem;
+  private templatesRootPath;
   private templateService;
-  private isMonolith;
-  constructor(templatesPath: string, isMonolith?: boolean);
+  constructor(fileSystem: IFileSystemService, templatesRootPath: string);
+  listScaffoldingMethods(projectPath: string, cursor?: string): Promise<ListScaffoldingMethodsResult>;
   /**
-   * Get the tool definition for MCP
+   * Collects all scaffold methods for a template (no pagination)
+   * Used internally for lookups that need to search all methods
    */
-  getDefinition(): ToolDefinition;
+  private collectAllMethodsByTemplate;
+  listScaffoldingMethodsByTemplate(templateName: string, cursor?: string): Promise<ListScaffoldingMethodsResult>;
   /**
-   * Execute the tool
+   * Gets scaffolding methods with instructions rendered using provided variables
    */
-  execute(args?: Record<string, any>): Promise<CallToolResult>;
-}
-//#endregion
-//#region src/tools/ListScaffoldingMethodsTool.d.ts
-declare class ListScaffoldingMethodsTool {
-  static readonly TOOL_NAME = "list-scaffolding-methods";
-  private fileSystemService;
-  private scaffoldingMethodsService;
-  private templateService;
-  private isMonolith;
-  constructor(templatesPath: string, isMonolith?: boolean);
+  listScaffoldingMethodsWithVariables(projectPath: string, variables: Record<string, any>, cursor?: string): Promise<ListScaffoldingMethodsResult>;
   /**
-   * Get the tool definition for MCP
+   * Processes scaffold instruction with template service
    */
-  getDefinition(): ToolDefinition;
+  processScaffoldInstruction(instruction: string, variables: Record<string, any>): string;
+  private findTemplatePath;
   /**
-   * Execute the tool
+   * Resolves the project path, handling both monorepo and monolith cases
+   * Uses ProjectConfigResolver to find the correct workspace/project root
    */
-  execute(args: Record<string, any>): Promise<CallToolResult>;
+  private resolveProjectPath;
+  /**
+   * Dynamically discovers all template directories
+   * Supports both flat structure (templates/nextjs-15) and nested structure (templates/apps/nextjs-15)
+   **/
+  private discoverTemplateDirs;
+  useScaffoldMethod(request: UseScaffoldMethodRequest): Promise<ScaffoldResult>;
 }
 //#endregion
-//#region src/tools/UseBoilerplateTool.d.ts
-declare class UseBoilerplateTool {
-  static readonly TOOL_NAME = "use-boilerplate";
-  private boilerplateService;
-  private templateService;
-  private isMonolith;
-  constructor(templatesPath: string, isMonolith?: boolean);
+//#region src/services/ScaffoldProcessingService.d.ts
+/**
+ * Shared service for common scaffolding operations like processing templates and tracking files
+ */
+declare class ScaffoldProcessingService {
+  private fileSystem;
+  private variableReplacer;
+  constructor(fileSystem: IFileSystemService, variableReplacer: IVariableReplacementService);
   /**
-   * Get the tool definition for MCP
+   * Process a target path for variable replacement, handling both files and directories
    */
-  getDefinition(): ToolDefinition;
+  processTargetForVariableReplacement(targetPath: string, variables: Record<string, any>): Promise<void>;
   /**
-   * Execute the tool
+   * Track all created files, handling both single files and directories
    */
-  execute(args: Record<string, any>): Promise<CallToolResult>;
-}
-//#endregion
-//#region src/tools/UseScaffoldMethodTool.d.ts
-declare class UseScaffoldMethodTool {
-  static readonly TOOL_NAME = "use-scaffold-method";
-  private static readonly TEMP_LOG_DIR;
-  private fileSystemService;
-  private scaffoldingMethodsService;
-  private isMonolith;
-  constructor(templatesPath: string, isMonolith?: boolean);
+  trackCreatedFiles(targetPath: string, createdFiles: string[]): Promise<void>;
   /**
-   * Write scaffold execution info to temp log file for hook processing
+   * Track all existing files, handling both single files and directories
    */
-  private writePendingScaffoldLog;
+  trackExistingFiles(targetPath: string, existingFiles: string[]): Promise<void>;
   /**
-   * Get the tool definition for MCP
+   * Copy source to target, then process templates and track files
+   * Now supports tracking existing files separately from created files
+   * Automatically handles .liquid template files by stripping the extension
    */
-  getDefinition(): ToolDefinition;
+  copyAndProcess(sourcePath: string, targetPath: string, variables: Record<string, any>, createdFiles: string[], existingFiles?: string[]): Promise<void>;
   /**
-   * Execute the tool
+   * Recursively collect all file paths in a directory for created files
    */
-  execute(args: Record<string, any>): Promise<CallToolResult>;
+  private trackCreatedFilesRecursive;
+  /**
+   * Recursively collect all file paths in a directory for existing files
+   */
+  private trackExistingFilesRecursive;
 }
 //#endregion
-//#region src/tools/WriteToFileTool.d.ts
-declare class WriteToFileTool {
-  static readonly TOOL_NAME = "write-to-file";
-  private fileSystemService;
-  constructor();
+//#region src/services/ScaffoldService.d.ts
+declare class ScaffoldService implements IScaffoldService {
+  private fileSystem;
+  private scaffoldConfigLoader;
+  private variableReplacer;
+  static readonly DEFAULT_MARKER = "@scaffold-generated";
+  private readonly templatesRootPath;
+  private readonly processingService;
+  constructor(fileSystem: IFileSystemService, scaffoldConfigLoader: IScaffoldConfigLoader, variableReplacer: IVariableReplacementService, templatesRootPath?: string);
   /**
-   * Get the tool definition for MCP
+   * Scaffold a new project from a boilerplate template
    */
-  getDefinition(): ToolDefinition;
+  useBoilerplate(options: BoilerplateOptions): Promise<ScaffoldResult>;
   /**
-   * Execute the tool
+   * Scaffold a new feature into an existing project
    */
-  execute(args: Record<string, any>): Promise<CallToolResult>;
-}
-//#endregion
-//#region src/transports/types.d.ts
-/**
- * Transport mode types
- */
-declare enum TransportMode {
-  STDIO = "stdio",
-  HTTP = "http",
-  SSE = "sse",
-  CLI = "cli",
-}
-/**
- * Transport configuration options
- */
-interface TransportConfig {
-  mode: TransportMode;
-  port?: number;
-  host?: string;
-}
-/**
- * Base interface for all transport handlers
- */
-interface TransportHandler {
-  start(): Promise<void>;
-  stop(): Promise<void>;
-}
-/**
- * HTTP transport specific types
- */
-interface HttpTransportHandler$1 extends TransportHandler {
-  getPort(): number;
-  getHost(): string;
+  useFeature(options: FeatureOptions): Promise<ScaffoldResult>;
+  /**
+   * Inject scaffold marker comment into generated code files.
+   * Prepends `// <marker>` to .ts/.tsx/.js/.jsx files that don't already have it.
+   * Fails silently — marker injection should never break scaffold output.
+   */
+  private injectScaffoldMarkers;
+  /**
+   * Common scaffolding processing logic shared by both useBoilerplate and useFeature
+   */
+  private processScaffold;
 }
 //#endregion
-//#region src/transports/http.d.ts
-/**
- * HTTP transport handler using Streamable HTTP (protocol version 2025-03-26)
- * Provides stateful session management with resumability support
- */
-declare class HttpTransportHandler implements HttpTransportHandler$1 {
-  private serverFactory;
-  private app;
-  private server;
-  private sessionManager;
-  private config;
-  constructor(serverFactory: Server | (() => Server), config: TransportConfig);
-  private setupMiddleware;
-  private setupRoutes;
-  private handlePostRequest;
-  private handleGetRequest;
-  private handleDeleteRequest;
-  start(): Promise<void>;
-  stop(): Promise<void>;
-  getPort(): number;
-  getHost(): string;
+//#region src/services/TemplateService.d.ts
+interface ITemplateService$1 {
+  renderString(template: string, variables: Record<string, any>): string;
+  containsTemplateVariables(content: string): boolean;
 }
-//#endregion
-//#region src/transports/sse.d.ts
-/**
- * SSE (Server-Sent Events) transport handler
- * Legacy transport for backwards compatibility (protocol version 2024-11-05)
- * Uses separate endpoints: /sse for SSE stream (GET) and /messages for client messages (POST)
- */
-declare class SseTransportHandler implements HttpTransportHandler$1 {
-  private serverFactory;
-  private app;
-  private server;
-  private sessionManager;
-  private config;
-  constructor(serverFactory: Server | (() => Server), config: TransportConfig);
-  private setupMiddleware;
-  private setupRoutes;
-  private handleSseConnection;
-  private handlePostMessage;
-  start(): Promise<void>;
-  stop(): Promise<void>;
-  getPort(): number;
-  getHost(): string;
+declare class TemplateService implements ITemplateService$1 {
+  private liquid;
+  constructor();
+  private toPascalCase;
+  private setupCustomFilters;
+  renderString(template: string, variables: Record<string, any>): string;
+  containsTemplateVariables(content: string): boolean;
 }
 //#endregion
-//#region src/transports/stdio.d.ts
-/**
- * Stdio transport handler for MCP server
- * Used for command-line and direct integrations
- */
-declare class StdioTransportHandler implements TransportHandler {
-  private server;
-  private transport;
-  constructor(server: Server);
-  start(): Promise<void>;
-  stop(): Promise<void>;
+//#region src/services/VariableReplacementService.d.ts
+declare class VariableReplacementService implements IVariableReplacementService {
+  private fileSystem;
+  private templateService;
+  private readonly binaryExtensions;
+  constructor(fileSystem: IFileSystemService, templateService: ITemplateService);
+  processFilesForVariableReplacement(dirPath: string, variables: Record<string, any>): Promise<void>;
+  replaceVariablesInFile(filePath: string, variables: Record<string, any>): Promise<void>;
+  isBinaryFile(filePath: string): boolean;
 }
 //#endregion
 //#region src/types/tools.d.ts
@@ -943,4 +953,4 @@ interface Tool {
   execute: (args: unknown) => Promise<string>;
 }
 //#endregion
-export { ArchitectConfig, BoilerplateConfig, BoilerplateGeneratorService, BoilerplateInfo, BoilerplateOptions, BoilerplateService, FeatureConfig, FeatureOptions, FileSystemService, GenerateBoilerplateFileTool, GenerateBoilerplateTool, GenerateFeatureScaffoldTool, GeneratorContext, GeneratorFunction, HttpTransportHandler, IFileSystemService, INunjucksService, IScaffoldConfigLoader, IScaffoldService, ITemplateParserService, ITemplateService, IVariableReplacementService, ListBoilerplateResponse, ListBoilerplatesTool, ListScaffoldingMethodsTool, PaginationMeta, ParsedInclude, ScaffoldArgs, ScaffoldConfigEntry, ScaffoldConfigLoader, ScaffoldGeneratorService, ScaffoldProcessingService, ScaffoldResult, ScaffoldService, ScaffoldYamlConfig, ScaffoldingMethodsService, SseTransportHandler, StdioTransportHandler, TemplateService, TemplateValidationResult, TemplateVariables, Tool, UseBoilerplateRequest, UseBoilerplateTool, UseScaffoldMethodTool, VariableReplacementService, VariablesSchema, WriteToFileTool, scaffoldArgsSchema };
+export { ArchitectConfig, BoilerplateConfig, BoilerplateGeneratorService, BoilerplateInfo, BoilerplateOptions, BoilerplateService, FeatureConfig, FeatureOptions, FileSystemService, GenerateBoilerplateFileTool, GenerateBoilerplateTool, GenerateFeatureScaffoldTool, GeneratorContext, GeneratorFunction, HttpTransportHandler, IFileSystemService, INunjucksService, IScaffoldConfigLoader, IScaffoldService, ITemplateParserService, ITemplateService, IVariableReplacementService, ListBoilerplateResponse, ListBoilerplatesTool, ListScaffoldingMethodsTool, PaginationMeta, ParsedInclude, ScaffoldArgs, ScaffoldConfigEntry, ScaffoldConfigLoader, ScaffoldGeneratorService, ScaffoldProcessingService, ScaffoldResult, ScaffoldService, ScaffoldYamlConfig, ScaffoldingMethodsService, type ServerOptions, SseTransportHandler, StdioTransportHandler, TemplateService, TemplateValidationResult, TemplateVariables, Tool, type TransportConfig, type TransportHandler, TransportMode, UseBoilerplateRequest, UseBoilerplateTool, UseScaffoldMethodTool, VariableReplacementService, VariablesSchema, WriteToFileTool, createServer, scaffoldArgsSchema };