@agiflowai/scaffold-mcp 0.6.0 → 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,815 @@
+import { JsonSchema } from "@composio/json-schema-to-zod";
+import { z } from "zod";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import "express";
+
+//#region src/services/BoilerplateGeneratorService.d.ts
+interface GenerateBoilerplateOptions {
+  templateName: string;
+  boilerplateName: string;
+  description: string;
+  instruction?: string;
+  targetFolder: string;
+  variables: Array<{
+    name: string;
+    description: string;
+    type: string;
+    required: boolean;
+    default?: any;
+  }>;
+  includes?: string[];
+}
+/**
+ * Service for generating boilerplate configurations in scaffold.yaml files
+ */
+declare class BoilerplateGeneratorService {
+  private templatesPath;
+  constructor(templatesPath: string);
+  /**
+   * Custom YAML dumper that forces literal block style (|) for description and instruction fields
+   */
+  private dumpYamlWithLiteralBlocks;
+  /**
+   * Process config to ensure description and instruction use literal block style
+   */
+  private processConfigForLiteralBlocks;
+  /**
+   * Ensure string is properly formatted for YAML literal blocks
+   */
+  private ensureMultilineFormat;
+  /**
+   * Generate or update a boilerplate configuration in scaffold.yaml
+   */
+  generateBoilerplate(options: GenerateBoilerplateOptions): Promise<{
+    success: boolean;
+    message: string;
+    templatePath?: string;
+    scaffoldYamlPath?: string;
+  }>;
+  /**
+   * List all templates (directories in templates folder)
+   */
+  listTemplates(): Promise<string[]>;
+  /**
+   * Check if a template exists
+   */
+  templateExists(templateName: string): Promise<boolean>;
+  /**
+   * Create or update a template file for a boilerplate
+   */
+  createTemplateFile(options: {
+    templateName: string;
+    filePath: string;
+    content?: string;
+    sourceFile?: string;
+    header?: string;
+  }): Promise<{
+    success: boolean;
+    message: string;
+    filePath?: string;
+    fullPath?: string;
+  }>;
+}
+//#endregion
+//#region src/types/boilerplateTypes.d.ts
+interface BoilerplateConfig {
+  name: string;
+  description: string;
+  instruction: string;
+  variables_schema: JsonSchema;
+  includes: string[];
+  targetFolder: string;
+}
+interface FeatureConfig {
+  name: string;
+  generator: string;
+  instruction: string;
+  variables_schema: JsonSchema;
+  includes: string[];
+}
+interface ScaffoldYamlConfig {
+  boilerplate?: BoilerplateConfig[];
+  feature?: FeatureConfig[];
+}
+interface BoilerplateInfo {
+  name: string;
+  description: string;
+  instruction: string;
+  variables_schema: JsonSchema;
+  template_path: string;
+  target_folder: string;
+  includes: string[];
+}
+interface UseBoilerplateRequest {
+  boilerplateName?: string;
+  variables: Record<string, any>;
+  monolith?: boolean;
+  targetFolderOverride?: string;
+}
+interface ListBoilerplateResponse {
+  boilerplates: BoilerplateInfo[];
+}
+//#endregion
+//#region src/types/interfaces.d.ts
+/**
+ * Interface for file system operations
+ */
+interface IFileSystemService {
+  pathExists(path: string): Promise<boolean>;
+  readFile(path: string, encoding?: BufferEncoding): Promise<string>;
+  readJson(path: string): Promise<any>;
+  writeFile(path: string, content: string, encoding?: BufferEncoding): Promise<void>;
+  ensureDir(path: string): Promise<void>;
+  copy(src: string, dest: string): Promise<void>;
+  readdir(path: string): Promise<string[]>;
+  stat(path: string): Promise<{
+    isDirectory(): boolean;
+    isFile(): boolean;
+  }>;
+}
+/**
+ * Interface for template rendering
+ */
+interface ITemplateService {
+  renderString(template: string, variables: Record<string, any>): string;
+  containsTemplateVariables(content: string): boolean;
+}
+type INunjucksService = ITemplateService;
+/**
+ * Interface for scaffold config loading operations
+ */
+interface IScaffoldConfigLoader {
+  parseArchitectConfig(templatePath: string): Promise<ArchitectConfig | null>;
+  parseIncludeEntry(includeEntry: string, variables: Record<string, any>): ParsedInclude;
+  replaceVariablesInPath(pathStr: string, variables: Record<string, any>): string;
+  shouldIncludeFile(conditions: Record<string, string> | undefined, variables: Record<string, any>): boolean;
+  validateTemplate(templatePath: string, scaffoldType: string): Promise<TemplateValidationResult>;
+}
+/**
+ * Interface for variable replacement in files
+ */
+interface IVariableReplacementService {
+  processFilesForVariableReplacement(dirPath: string, variables: Record<string, any>): Promise<void>;
+  replaceVariablesInFile(filePath: string, variables: Record<string, any>): Promise<void>;
+  isBinaryFile(filePath: string): boolean;
+}
+/**
+ * Main scaffold service interface
+ */
+interface IScaffoldService {
+  useBoilerplate(options: BoilerplateOptions): Promise<ScaffoldResult>;
+  useFeature(options: FeatureOptions): Promise<ScaffoldResult>;
+}
+type ITemplateParserService = IScaffoldConfigLoader;
+//#endregion
+//#region src/types/scaffold.d.ts
+interface BoilerplateOptions {
+  projectName: string;
+  packageName: string;
+  targetFolder: string;
+  templateFolder: string;
+  boilerplateName: string;
+  variables?: Record<string, any>;
+}
+interface FeatureOptions {
+  projectPath: string;
+  templateFolder: string;
+  featureName: string;
+  variables?: Record<string, any>;
+}
+interface ArchitectConfig {
+  [key: string]: {
+    name: string;
+    description: string;
+    variables_schema: {
+      type: string;
+      properties: Record<string, any>;
+      required: string[];
+      additionalProperties: boolean;
+    };
+    includes: string[];
+    generator?: string;
+  };
+}
+interface ParsedInclude {
+  sourcePath: string;
+  targetPath: string;
+  conditions?: Record<string, string>;
+}
+interface ScaffoldResult {
+  success: boolean;
+  message: string;
+  warnings?: string[];
+  createdFiles?: string[];
+  existingFiles?: string[];
+}
+interface TemplateValidationResult {
+  isValid: boolean;
+  errors: string[];
+  missingFiles: string[];
+}
+interface GeneratorContext {
+  variables: Record<string, any>;
+  config: ArchitectConfig[string];
+  targetPath: string;
+  templatePath: string;
+  fileSystem: IFileSystemService;
+  scaffoldConfigLoader: IScaffoldConfigLoader;
+  variableReplacer: IVariableReplacementService;
+}
+type GeneratorFunction = (context: GeneratorContext) => Promise<ScaffoldResult>;
+//#endregion
+//#region src/services/BoilerplateService.d.ts
+declare class BoilerplateService {
+  private templatesPath;
+  private templateService;
+  private scaffoldService;
+  constructor(templatesPath: string);
+  /**
+   * Scans all scaffold.yaml files and returns available boilerplates
+   */
+  listBoilerplates(): Promise<ListBoilerplateResponse>;
+  /**
+   * Dynamically discovers template directories by finding all directories
+   * that contain both package.json and scaffold.yaml files
+   */
+  private discoverTemplateDirectories;
+  /**
+   * Executes a specific boilerplate with provided variables
+   */
+  useBoilerplate(request: UseBoilerplateRequest): Promise<ScaffoldResult>;
+  /**
+   * Gets a specific boilerplate configuration by name with optional variable rendering
+   */
+  getBoilerplate(name: string, variables?: Record<string, any>): Promise<BoilerplateInfo | null>;
+  /**
+   * Processes boilerplate instruction with template service
+   */
+  processBoilerplateInstruction(instruction: string, variables: Record<string, any>): string;
+  /**
+   * Validates boilerplate variables against schema using Zod
+   */
+  validateBoilerplateVariables(boilerplate: BoilerplateInfo, variables: Record<string, any>): {
+    isValid: boolean;
+    errors: string[];
+  };
+}
+//#endregion
+//#region src/services/FileSystemService.d.ts
+declare class FileSystemService implements IFileSystemService {
+  pathExists(path: string): Promise<boolean>;
+  readFile(path: string, encoding?: BufferEncoding): Promise<string>;
+  readJson(path: string): Promise<any>;
+  writeFile(path: string, content: string, encoding?: BufferEncoding): Promise<void>;
+  ensureDir(path: string): Promise<void>;
+  copy(src: string, dest: string): Promise<void>;
+  readdir(path: string): Promise<string[]>;
+  stat(path: string): Promise<{
+    isDirectory(): boolean;
+    isFile(): boolean;
+  }>;
+}
+//#endregion
+//#region src/services/ScaffoldConfigLoader.d.ts
+
+declare class ScaffoldConfigLoader implements IScaffoldConfigLoader {
+  private fileSystem;
+  private templateService;
+  constructor(fileSystem: IFileSystemService, templateService: ITemplateService);
+  parseArchitectConfig(templatePath: string): Promise<ArchitectConfig | null>;
+  parseIncludeEntry(includeEntry: string, variables: Record<string, any>): ParsedInclude;
+  replaceVariablesInPath(pathStr: string, variables: Record<string, any>): string;
+  shouldIncludeFile(conditions: Record<string, string> | undefined, variables: Record<string, any>): boolean;
+  validateTemplate(templatePath: string, scaffoldType: string): Promise<TemplateValidationResult>;
+}
+//#endregion
+//#region src/services/ScaffoldGeneratorService.d.ts
+interface GenerateFeatureScaffoldOptions {
+  templateName: string;
+  featureName: string;
+  description: string;
+  instruction?: string;
+  variables: Array<{
+    name: string;
+    description: string;
+    type: string;
+    required: boolean;
+    default?: any;
+  }>;
+  includes?: string[];
+  patterns?: string[];
+}
+/**
+ * Service for generating feature scaffold configurations in scaffold.yaml files
+ */
+declare class ScaffoldGeneratorService {
+  private templatesPath;
+  constructor(templatesPath: string);
+  /**
+   * Custom YAML dumper that forces literal block style (|) for description and instruction fields
+   */
+  private dumpYamlWithLiteralBlocks;
+  /**
+   * Process config to ensure description and instruction use literal block style
+   */
+  private processConfigForLiteralBlocks;
+  /**
+   * Ensure string is properly formatted for YAML literal blocks
+   */
+  private ensureMultilineFormat;
+  /**
+   * Generate or update a feature configuration in scaffold.yaml
+   */
+  generateFeatureScaffold(options: GenerateFeatureScaffoldOptions): Promise<{
+    success: boolean;
+    message: string;
+    templatePath?: string;
+    scaffoldYamlPath?: string;
+  }>;
+  /**
+   * List all templates (directories in templates folder)
+   */
+  listTemplates(): Promise<string[]>;
+  /**
+   * Check if a template exists
+   */
+  templateExists(templateName: string): Promise<boolean>;
+}
+//#endregion
+//#region src/services/ScaffoldingMethodsService.d.ts
+interface ScaffoldMethod {
+  name: string;
+  description?: string;
+  instruction?: string;
+  variables_schema: {
+    type: string;
+    properties: Record<string, any>;
+    required: string[];
+    additionalProperties: boolean;
+  };
+  generator?: string;
+}
+interface ListScaffoldingMethodsResult {
+  sourceTemplate: string;
+  templatePath: string;
+  methods: ScaffoldMethod[];
+}
+interface UseScaffoldMethodRequest {
+  projectPath: string;
+  scaffold_feature_name: string;
+  variables: Record<string, any>;
+}
+declare class ScaffoldingMethodsService {
+  private fileSystem;
+  private templatesRootPath;
+  private templateService;
+  constructor(fileSystem: IFileSystemService, templatesRootPath: string);
+  listScaffoldingMethods(projectPath: string): Promise<ListScaffoldingMethodsResult>;
+  listScaffoldingMethodsByTemplate(templateName: string): Promise<ListScaffoldingMethodsResult>;
+  /**
+   * Gets scaffolding methods with instructions rendered using provided variables
+   */
+  listScaffoldingMethodsWithVariables(projectPath: string, variables: Record<string, any>): 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;
+  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>;
+  /**
+   * 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>;
+}
+//#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 fileSystemService;
+  private scaffoldingMethodsService;
+  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/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/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/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/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/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/types/tools.d.ts
+declare const scaffoldArgsSchema: z.ZodObject<{
+  appName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+  appName: string;
+}, {
+  appName: string;
+}>;
+type ScaffoldArgs = z.infer<typeof scaffoldArgsSchema>;
+interface Tool {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: 'object';
+    properties: Record<string, any>;
+    required: string[];
+  };
+  execute: (args: unknown) => Promise<string>;
+}
+//#endregion
+//#region src/utils/git.d.ts
+/**
+ * Find the workspace root by searching upwards for .git folder
+ * Returns null if no .git folder is found (indicating a new project setup is needed)
+ */
+declare function findWorkspaceRoot(startPath?: string): Promise<string | null>;
+/**
+ * Parse GitHub URL to detect if it's a subdirectory
+ * Supports formats:
+ * - https://github.com/user/repo
+ * - https://github.com/user/repo/tree/branch/path/to/dir
+ * - https://github.com/user/repo/tree/main/path/to/dir
+ */
+declare function parseGitHubUrl(url: string): {
+  owner?: string;
+  repo?: string;
+  repoUrl: string;
+  branch?: string;
+  subdirectory?: string;
+  isSubdirectory: boolean;
+};
+/**
+ * Clone a subdirectory from a git repository using sparse checkout
+ */
+declare function cloneSubdirectory(repoUrl: string, branch: string, subdirectory: string, targetFolder: string): Promise<void>;
+/**
+ * Clone entire repository
+ */
+declare function cloneRepository(repoUrl: string, targetFolder: string): Promise<void>;
+/**
+ * Fetch directory listing from GitHub API
+ */
+declare function fetchGitHubDirectoryContents(owner: string, repo: string, path: string, branch?: string): Promise<Array<{
+  name: string;
+  type: string;
+  path: 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, ParsedInclude, ScaffoldArgs, ScaffoldConfigLoader, ScaffoldGeneratorService, ScaffoldProcessingService, ScaffoldResult, ScaffoldService, ScaffoldYamlConfig, ScaffoldingMethodsService, SseTransportHandler, StdioTransportHandler, TemplateService, TemplateValidationResult, Tool, UseBoilerplateRequest, UseBoilerplateTool, UseScaffoldMethodTool, VariableReplacementService, WriteToFileTool, cloneRepository, cloneSubdirectory, fetchGitHubDirectoryContents, findWorkspaceRoot, parseGitHubUrl, scaffoldArgsSchema };