@qazuor/claude-code-config 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1325 @@
+/**
+ * Folder structure preferences based on selected bundles
+ */
+/**
+ * Test files location preference
+ */
+type TestFileLocation = 'colocated' | 'test-folder-root' | 'test-folder-src';
+/**
+ * Planning files location preference
+ */
+type PlanningFileLocation = 'claude-sessions' | 'docs-planning' | 'root-planning';
+/**
+ * Documentation files location preference
+ */
+type DocsFileLocation = 'docs-root' | 'claude-docs' | 'readme-only';
+/**
+ * CI/CD configuration location
+ */
+type CiCdLocation = 'github-workflows' | 'gitlab-ci' | 'custom';
+/**
+ * Folder structure preferences
+ */
+interface FolderPreferences {
+    /** Test files location */
+    tests?: {
+        location: TestFileLocation;
+        /** Test file naming pattern (e.g., "*.test.ts", "*.spec.ts") */
+        pattern: string;
+    };
+    /** Planning/sessions files location */
+    planning?: {
+        location: PlanningFileLocation;
+        /** Whether to commit planning files to git */
+        commitToGit: boolean;
+    };
+    /** Documentation files location */
+    docs?: {
+        location: DocsFileLocation;
+    };
+    /** CI/CD configuration */
+    cicd?: {
+        location: CiCdLocation;
+        /** Selected workflow templates */
+        workflows: string[];
+    };
+}
+
+/**
+ * MCP (Model Context Protocol) server types
+ */
+/**
+ * MCP server categories
+ */
+type McpCategory = 'documentation' | 'database' | 'cache' | 'version-control' | 'deployment' | 'infrastructure' | 'project-mgmt' | 'monitoring' | 'testing' | 'security' | 'communication' | 'design' | 'payments' | 'search' | 'ai' | 'custom';
+/**
+ * Configuration field for MCP servers that require setup
+ */
+interface McpConfigField {
+    /** Field name */
+    name: string;
+    /** Field type */
+    type: 'string' | 'boolean' | 'number';
+    /** Whether this field is required */
+    required: boolean;
+    /** Description for user prompt */
+    description: string;
+    /** Environment variable to read from (optional) */
+    envVar?: string;
+    /** Default value (optional) */
+    default?: string | boolean | number;
+}
+/**
+ * MCP server definition
+ */
+interface McpServerDefinition {
+    /** Unique server identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Description of what this server provides */
+    description: string;
+    /** npm package or command to run */
+    package: string;
+    /** Server category */
+    category: McpCategory;
+    /** Whether this server requires configuration */
+    requiresConfig: boolean;
+    /** Configuration fields (if requiresConfig is true) */
+    configFields?: McpConfigField[];
+    /** Installation instructions (optional) */
+    installInstructions?: string;
+}
+/**
+ * MCP server installation record
+ */
+interface McpInstallation {
+    /** Server ID from definition */
+    serverId: string;
+    /** Installation level */
+    level: 'user' | 'project';
+    /** Configuration values */
+    config: Record<string, unknown>;
+}
+
+/**
+ * Permission configuration types for Claude Code
+ */
+/**
+ * Permission preset names
+ */
+type PermissionPreset = 'default' | 'trust' | 'restrictive' | 'custom';
+/**
+ * File operation permissions
+ */
+interface FilePermissions {
+    /** Allow Read on all files */
+    readAll: boolean;
+    /** Allow Write on code files (*.ts, *.js, *.tsx, *.jsx) */
+    writeCode: boolean;
+    /** Allow Write on config files (*.json, *.yaml, *.toml) */
+    writeConfig: boolean;
+    /** Allow Write on markdown files (*.md) */
+    writeMarkdown: boolean;
+    /** Allow Write on other file types */
+    writeOther: boolean;
+    /** Allow Edit tool */
+    editTool: boolean;
+}
+/**
+ * Git operation permissions
+ */
+interface GitPermissions {
+    /** Allow read-only operations (status, diff, log) */
+    readOnly: boolean;
+    /** Allow staging (git add) */
+    staging: boolean;
+    /** Allow commit */
+    commit: boolean;
+    /** Allow push (dangerous) */
+    push: boolean;
+    /** Allow branching (checkout, branch) */
+    branching: boolean;
+}
+/**
+ * Bash/Terminal permissions
+ */
+interface BashPermissions {
+    /** Allow package manager commands (pnpm, npm, yarn) */
+    packageManager: boolean;
+    /** Allow test commands (vitest, jest) */
+    testing: boolean;
+    /** Allow build commands */
+    building: boolean;
+    /** Allow docker commands */
+    docker: boolean;
+    /** Allow arbitrary bash commands (dangerous) */
+    arbitrary: boolean;
+}
+/**
+ * Web operation permissions
+ */
+interface WebPermissions {
+    /** Allow WebFetch tool */
+    fetch: boolean;
+    /** Allow WebSearch tool */
+    search: boolean;
+}
+/**
+ * Custom permission rules
+ */
+interface CustomPermissions {
+    /** Additional allow patterns */
+    allow: string[];
+    /** Additional deny patterns */
+    deny: string[];
+}
+/**
+ * Full permissions configuration
+ */
+interface PermissionsConfig {
+    /** Selected preset */
+    preset: PermissionPreset;
+    /** File operation permissions */
+    files: FilePermissions;
+    /** Git operation permissions */
+    git: GitPermissions;
+    /** Bash/Terminal permissions */
+    bash: BashPermissions;
+    /** Web operation permissions */
+    web: WebPermissions;
+    /** Custom rules */
+    custom: CustomPermissions;
+}
+
+/**
+ * Project scaffold types
+ */
+/**
+ * Scaffold type options
+ */
+type ScaffoldType = 'claude-only' | 'full-project';
+/**
+ * Supported project types for scaffolding
+ */
+type ProjectType = 'node' | 'monorepo' | 'astro' | 'nextjs' | 'vite-react' | 'hono' | 'custom';
+/**
+ * Supported package managers
+ */
+type PackageManager = 'pnpm' | 'npm' | 'yarn' | 'bun';
+/**
+ * Scaffold options from user selection
+ */
+interface ScaffoldOptions {
+    /** Type of scaffold to perform */
+    type: ScaffoldType;
+    /** Project type (only for full-project) */
+    projectType?: ProjectType;
+    /** Package manager to use */
+    packageManager?: PackageManager;
+    /** Initialize git repository */
+    initGit?: boolean;
+    /** Create README.md */
+    createReadme?: boolean;
+    /** Create .gitignore */
+    createGitignore?: boolean;
+}
+/**
+ * Scaffold operation result
+ */
+interface ScaffoldResult {
+    /** Files created */
+    createdFiles: string[];
+    /** Directories created */
+    createdDirs: string[];
+    /** Post-install instructions */
+    instructions: string[];
+}
+/**
+ * Project detection signal
+ */
+interface DetectionSignal {
+    /** File or pattern that was found */
+    file: string;
+    /** Whether it exists */
+    exists: boolean;
+    /** What it indicates */
+    indicates: string;
+}
+/**
+ * Project detection result
+ */
+interface ProjectDetectionResult {
+    /** Whether a project was detected */
+    detected: boolean;
+    /** Detected project type */
+    projectType?: ProjectType;
+    /** Detected package manager */
+    packageManager?: PackageManager;
+    /** Suggested bundle IDs based on detection */
+    suggestedBundles?: string[];
+    /** Detected technologies (e.g., ['react', 'typescript', 'tailwind']) */
+    detectedTechnologies?: string[];
+    /** Overall confidence */
+    confidence: 'high' | 'medium' | 'low';
+    /** Signals that were found */
+    signals: DetectionSignal[];
+}
+
+/**
+ * User's template configuration - Commands
+ */
+interface TemplateConfigCommands {
+    typecheck?: string;
+    lint?: string;
+    test?: string;
+    coverage?: string;
+    build?: string;
+    format?: string;
+    securityScan?: string;
+    lighthouse?: string;
+    bundleAnalyze?: string;
+}
+/**
+ * User's template configuration - Paths
+ */
+interface TemplateConfigPaths {
+    planningPath?: string;
+    refactorPath?: string;
+    archivePath?: string;
+    schemasPath?: string;
+    projectRoot?: string;
+}
+/**
+ * User's template configuration - Targets
+ */
+interface TemplateConfigTargets {
+    coverageTarget?: number;
+    bundleSizeTarget?: number;
+    lcpTarget?: number;
+    fidTarget?: number;
+    clsTarget?: number;
+    apiResponseTarget?: number;
+    dbQueryTarget?: number;
+    wcagLevel?: 'A' | 'AA' | 'AAA';
+}
+/**
+ * User's template configuration - Tracking
+ */
+interface TemplateConfigTracking {
+    issueTracker?: 'github' | 'linear' | 'jira' | 'none';
+    trackingFile?: string;
+    registryFile?: string;
+    taskCodePattern?: string;
+    closedDays?: number;
+    staleDays?: number;
+}
+/**
+ * User's template configuration - Tech Stack
+ */
+interface TemplateConfigTechStack {
+    frontendFramework?: string;
+    databaseOrm?: string;
+    validationLibrary?: string;
+    authPattern?: string;
+    stateManagement?: string;
+    testFramework?: string;
+    bundler?: string;
+    apiFramework?: string;
+}
+/**
+ * User's template configuration - Environment Variables
+ */
+interface TemplateConfigEnvironment {
+    githubTokenEnv?: string;
+    githubOwnerEnv?: string;
+    githubRepoEnv?: string;
+    issueTrackerTokenEnv?: string;
+    issueTrackerOwnerEnv?: string;
+    issueTrackerRepoEnv?: string;
+}
+/**
+ * User's template configuration - Brand
+ */
+interface TemplateConfigBrand {
+    brandName?: string;
+    primaryColor?: string;
+    secondaryColor?: string;
+    fontFamily?: string;
+    toneOfVoice?: string;
+}
+/**
+ * Complete template configuration
+ */
+interface TemplateConfig {
+    /** CLI commands */
+    commands: TemplateConfigCommands;
+    /** Directory paths */
+    paths: TemplateConfigPaths;
+    /** Quality targets */
+    targets: TemplateConfigTargets;
+    /** Issue tracking */
+    tracking: TemplateConfigTracking;
+    /** Technology stack */
+    techStack: TemplateConfigTechStack;
+    /** Environment variables */
+    environment: TemplateConfigEnvironment;
+    /** Brand identity */
+    brand: TemplateConfigBrand;
+}
+
+/**
+ * Main configuration types for Claude Code config
+ */
+
+/**
+ * Template source configuration
+ */
+interface TemplateSource {
+    /** Whether using local bundled or remote templates */
+    type: 'local' | 'remote';
+    /** Git repository URL if remote */
+    repository?: string;
+    /** Branch or tag if remote */
+    ref?: string;
+    /** When the template was installed */
+    installedAt: string;
+}
+/**
+ * Project information for placeholder replacement
+ */
+interface ProjectInfo {
+    /** Project name */
+    name: string;
+    /** Brief project description */
+    description: string;
+    /** GitHub organization or username */
+    org: string;
+    /** Repository name */
+    repo: string;
+    /** Project domain (optional) */
+    domain?: string;
+    /** Primary entity type (singular) */
+    entityType: string;
+    /** Primary entity type (plural) */
+    entityTypePlural: string;
+    /** Location for examples (optional) */
+    location?: string;
+}
+/**
+ * User preferences
+ */
+interface Preferences {
+    /** Working language */
+    language: 'es' | 'en';
+    /** Language for Claude responses */
+    responseLanguage: 'es' | 'en';
+    /** Include Claude as commit co-author */
+    includeCoAuthor: boolean;
+    /** Preferred package manager */
+    packageManager?: PackageManager;
+}
+/**
+ * Module selection state
+ */
+interface ModuleSelection {
+    /** Selected module IDs */
+    selected: string[];
+    /** Excluded module IDs */
+    excluded: string[];
+}
+/**
+ * Hook configuration
+ */
+interface HookConfig {
+    /** Whether hooks are enabled */
+    enabled: boolean;
+    /** Notification hook customizations */
+    notification?: {
+        /** Enable desktop notifications */
+        desktop: boolean;
+        /** Enable audio notifications */
+        audio: boolean;
+        /** Custom notification command */
+        customCommand?: string;
+    };
+    /** Stop hook configuration */
+    stop?: {
+        /** Play beep sound */
+        beep?: boolean;
+        /** Custom sound file */
+        customSound?: string;
+        /** Custom command */
+        customCommand?: string;
+    };
+    /** Subagent stop hook configuration */
+    subagentStop?: {
+        /** Play beep sound */
+        beep?: boolean;
+        /** Custom sound file */
+        customSound?: string;
+        /** Custom command */
+        customCommand?: string;
+    };
+}
+/**
+ * MCP configuration
+ */
+interface McpConfig {
+    /** Installation level */
+    level: 'user' | 'project';
+    /** Installed MCP servers */
+    servers: McpInstallation[];
+}
+/**
+ * Scaffold configuration tracking
+ */
+interface ScaffoldConfig {
+    /** What type of scaffold was performed */
+    type: 'claude-only' | 'full-project';
+    /** List of created directories/files */
+    createdStructure: string[];
+}
+/**
+ * Customization tracking
+ */
+interface Customizations {
+    /** Whether placeholders were replaced */
+    placeholdersReplaced: boolean;
+    /** Last update timestamp */
+    lastUpdated: string;
+    /** Files that were manually modified */
+    customFiles: string[];
+    /** Permissions configuration (if custom) */
+    permissions?: PermissionsConfig;
+    /** Selected bundle IDs used during installation */
+    selectedBundles?: string[];
+}
+/**
+ * Modules configuration
+ */
+interface ModulesConfig {
+    /** Installed agents */
+    agents: ModuleSelection;
+    /** Installed skills */
+    skills: ModuleSelection;
+    /** Installed commands */
+    commands: ModuleSelection;
+    /** Installed docs */
+    docs: ModuleSelection;
+}
+/**
+ * Indent style options
+ */
+type IndentStyle = 'space' | 'tab';
+/**
+ * Quote style options
+ */
+type QuoteStyle = 'single' | 'double';
+/**
+ * EditorConfig options
+ */
+interface EditorConfigOptions {
+    /** Indent style (tabs or spaces) */
+    indentStyle: IndentStyle;
+    /** Indent size (number of spaces or tab width) */
+    indentSize: number;
+    /** Line ending style */
+    endOfLine: 'lf' | 'crlf' | 'cr';
+    /** Insert final newline */
+    insertFinalNewline: boolean;
+    /** Trim trailing whitespace */
+    trimTrailingWhitespace: boolean;
+    /** Character set */
+    charset: 'utf-8' | 'utf-8-bom' | 'latin1';
+    /** Max line length */
+    maxLineLength: number | 'off';
+}
+/**
+ * Biome formatter options
+ */
+interface BiomeFormatterOptions {
+    /** Indent style */
+    indentStyle: IndentStyle;
+    /** Indent width */
+    indentWidth: number;
+    /** Line width */
+    lineWidth: number;
+    /** Quote style for JS/TS */
+    quoteStyle: QuoteStyle;
+    /** Use semicolons */
+    semicolons: 'always' | 'asNeeded';
+    /** Trailing commas */
+    trailingCommas: 'all' | 'es5' | 'none';
+    /** Quote properties */
+    quoteProperties: 'asNeeded' | 'preserve';
+    /** Bracket spacing */
+    bracketSpacing: boolean;
+    /** Bracket same line (JSX) */
+    bracketSameLine: boolean;
+    /** Arrow function parentheses */
+    arrowParentheses: 'always' | 'asNeeded';
+}
+/**
+ * Biome linter options
+ */
+interface BiomeLinterOptions {
+    /** Enable recommended rules */
+    recommended: boolean;
+    /** Enable correctness rules */
+    correctness: boolean;
+    /** Enable suspicious code rules */
+    suspicious: boolean;
+    /** Enable style rules */
+    style: boolean;
+    /** Enable complexity rules */
+    complexity: boolean;
+    /** Enable security rules */
+    security: boolean;
+    /** Enable performance rules */
+    performance: boolean;
+    /** Enable accessibility rules */
+    a11y: boolean;
+}
+/**
+ * Biome configuration options
+ */
+interface BiomeOptions {
+    /** Formatter options */
+    formatter: BiomeFormatterOptions;
+    /** Linter options */
+    linter: BiomeLinterOptions;
+    /** Organize imports */
+    organizeImports: boolean;
+    /** Files to ignore */
+    ignorePatterns: string[];
+}
+/**
+ * Prettier options
+ */
+interface PrettierOptions {
+    /** Print width */
+    printWidth: number;
+    /** Tab width */
+    tabWidth: number;
+    /** Use tabs instead of spaces */
+    useTabs: boolean;
+    /** Use semicolons */
+    semi: boolean;
+    /** Use single quotes */
+    singleQuote: boolean;
+    /** JSX single quotes */
+    jsxSingleQuote: boolean;
+    /** Trailing commas */
+    trailingComma: 'all' | 'es5' | 'none';
+    /** Bracket spacing */
+    bracketSpacing: boolean;
+    /** Bracket same line (JSX) */
+    bracketSameLine: boolean;
+    /** Arrow function parentheses */
+    arrowParens: 'always' | 'avoid';
+    /** End of line */
+    endOfLine: 'lf' | 'crlf' | 'cr' | 'auto';
+    /** Prose wrap (for markdown) */
+    proseWrap: 'always' | 'never' | 'preserve';
+    /** HTML whitespace sensitivity */
+    htmlWhitespaceSensitivity: 'css' | 'strict' | 'ignore';
+    /** Single attribute per line (HTML/JSX) */
+    singleAttributePerLine: boolean;
+}
+/**
+ * Commitlint configuration options
+ */
+interface CommitlintOptions {
+    /** Extends base config */
+    extends: string[];
+    /** Commit types allowed */
+    types: string[];
+    /** Scopes allowed (empty for any) */
+    scopes: string[];
+    /** Maximum header length */
+    headerMaxLength: number;
+    /** Require scope */
+    scopeRequired: boolean;
+    /** Require body */
+    bodyRequired: boolean;
+    /** Body max line length */
+    bodyMaxLineLength: number;
+    /** Enable Husky integration */
+    huskyIntegration: boolean;
+}
+/**
+ * Code style configuration
+ */
+interface CodeStyleConfig {
+    /** Whether code style tools are enabled */
+    enabled: boolean;
+    /** EditorConfig file installed */
+    editorconfig: boolean;
+    /** EditorConfig options */
+    editorconfigOptions?: EditorConfigOptions;
+    /** Commitlint configuration installed */
+    commitlint: boolean;
+    /** Commitlint options */
+    commitlintOptions?: CommitlintOptions;
+    /** Biome configuration installed */
+    biome: boolean;
+    /** Biome options */
+    biomeOptions?: BiomeOptions;
+    /** Prettier configuration installed */
+    prettier: boolean;
+    /** Prettier options */
+    prettierOptions?: PrettierOptions;
+}
+/**
+ * Extra components configuration
+ */
+interface ExtrasConfig {
+    /** JSON schemas installed */
+    schemas: boolean;
+    /** Automation scripts installed */
+    scripts: boolean;
+    /** Hook configuration */
+    hooks: HookConfig;
+    /** Planning sessions structure */
+    sessions: boolean;
+    /** Code style configuration */
+    codeStyle?: CodeStyleConfig;
+    /** Folder structure preferences */
+    folderPreferences?: FolderPreferences;
+}
+/**
+ * Main Claude configuration stored in .claude/config.json
+ */
+interface ClaudeConfig {
+    /** CLI version that created this config */
+    version: string;
+    /** Template source information */
+    templateSource: TemplateSource;
+    /** Project-specific values */
+    project: ProjectInfo;
+    /** User preferences */
+    preferences: Preferences;
+    /** MCP configuration */
+    mcp: McpConfig;
+    /** Installed modules */
+    modules: ModulesConfig;
+    /** Extra components */
+    extras: ExtrasConfig;
+    /** Scaffold tracking */
+    scaffold: ScaffoldConfig;
+    /** Customization tracking */
+    customizations: Customizations;
+    /** Template placeholder configuration */
+    templateConfig?: Partial<TemplateConfig>;
+}
+
+/**
+ * Module registry and definition types
+ */
+/**
+ * Module categories
+ */
+type ModuleCategory = 'agents' | 'skills' | 'commands' | 'docs';
+/**
+ * Extended description for better user understanding
+ */
+interface ModuleExtendedInfo {
+    /** Detailed explanation of what this module does */
+    longDescription?: string;
+    /** List of specific capabilities or features */
+    whatItDoes?: string[];
+    /** When/why to use this module */
+    whenToUse?: string;
+    /** Technology stack this module is designed for */
+    techStack?: string[];
+    /** Alternative modules (e.g., "prisma" is alternative to "drizzle") */
+    alternativeTo?: string[];
+    /** Related modules that work well together */
+    relatedModules?: string[];
+    /** Skill level (beginner, intermediate, advanced) */
+    skillLevel?: 'beginner' | 'intermediate' | 'advanced';
+    /** Author or source of this module */
+    author?: string;
+    /** Version of the module */
+    version?: string;
+}
+/**
+ * Module definition in registry
+ */
+interface ModuleDefinition extends ModuleExtendedInfo {
+    /** Unique identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Short description (shown in selection lists) */
+    description: string;
+    /** Category this module belongs to */
+    category: ModuleCategory;
+    /** File path relative to category directory */
+    file: string;
+    /** Other modules this depends on */
+    dependencies?: string[];
+    /** Categorization tags */
+    tags?: string[];
+    /** Whether this is a core module (always installed) */
+    isCore?: boolean;
+    /** Bundle IDs that include this module (optional, can be computed) */
+    includedInBundles?: string[];
+    /** Placeholders used in this module's files */
+    placeholders?: string[];
+}
+/**
+ * Full module registry - all categories combined
+ */
+interface ModuleRegistry {
+    /** Agent modules */
+    agents: ModuleDefinition[];
+    /** Skill modules */
+    skills: ModuleDefinition[];
+    /** Command modules */
+    commands: ModuleDefinition[];
+    /** Documentation modules */
+    docs: ModuleDefinition[];
+}
+/**
+ * Resolved module ready for installation
+ */
+interface ResolvedModule$1 {
+    /** Module category */
+    category: ModuleCategory;
+    /** Module identifier */
+    id: string;
+    /** Module definition */
+    definition: ModuleDefinition;
+    /** Source path (in templates) */
+    sourcePath: string;
+    /** Target path (in .claude) */
+    targetPath: string;
+}
+/**
+ * Module selection result from prompts
+ */
+interface ModuleSelectionResult {
+    /** Selected agents by id */
+    agents: string[];
+    /** Selected skills by id */
+    skills: string[];
+    /** Selected commands by id */
+    commands: string[];
+    /** Selected docs by id */
+    docs: string[];
+}
+
+/**
+ * Bundle configuration types for grouping related modules
+ */
+
+/**
+ * Bundle categories for organizing bundles
+ */
+type BundleCategory = 'stack' | 'testing' | 'quality' | 'database' | 'api' | 'frontend' | 'workflow' | 'cicd';
+/**
+ * Bundle complexity level
+ */
+type BundleComplexity = 'minimal' | 'standard' | 'comprehensive';
+/**
+ * Module reference within a bundle
+ */
+interface BundleModuleRef {
+    /** Module ID */
+    id: string;
+    /** Module category (agents, skills, commands, docs) */
+    category: ModuleCategory;
+    /** Whether this module is optional in the bundle (nice to have) */
+    optional?: boolean;
+    /** IDs of modules that require this module to function properly */
+    requiredBy?: string[];
+}
+/**
+ * Detailed agent information for display
+ */
+interface AgentDetail {
+    /** Agent module ID */
+    id: string;
+    /** Primary role of the agent */
+    role: string;
+    /** Key responsibilities */
+    responsibilities: string[];
+}
+/**
+ * Detailed skill information for display
+ */
+interface SkillDetail {
+    /** Skill module ID */
+    id: string;
+    /** Purpose of the skill */
+    purpose: string;
+}
+/**
+ * Detailed command information for display
+ */
+interface CommandDetail {
+    /** Command module ID */
+    id: string;
+    /** Example usage */
+    usage: string;
+}
+/**
+ * Detailed doc information for display
+ */
+interface DocDetail {
+    /** Doc module ID */
+    id: string;
+    /** Topic the doc covers */
+    topic: string;
+}
+/**
+ * Detailed module information for rich display
+ */
+interface BundleModuleDetails {
+    /** Agent details with roles and responsibilities */
+    agents: AgentDetail[];
+    /** Skill details with purposes */
+    skills: SkillDetail[];
+    /** Command details with usage examples */
+    commands: CommandDetail[];
+    /** Doc details with topics */
+    docs: DocDetail[];
+}
+/**
+ * Bundle definition
+ */
+interface BundleDefinition {
+    /** Unique bundle identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Short description */
+    description: string;
+    /** Bundle category */
+    category: BundleCategory;
+    /** Modules included in this bundle */
+    modules: BundleModuleRef[];
+    /** Long description explaining what this bundle provides */
+    longDescription?: string;
+    /** Technology stack this bundle is designed for */
+    techStack?: string[];
+    /** Alternative bundles (e.g., "prisma-bundle" is alternative to "drizzle-bundle") */
+    alternativeTo?: string[];
+    /** Tags for filtering */
+    tags?: string[];
+    /** What problems this bundle solves */
+    responsibilities?: string[];
+    /** Scope/reach of the bundle */
+    scope?: string;
+    /** When to use this bundle */
+    useCases?: string[];
+    /** Bundles that should be installed before this one */
+    prerequisites?: string[];
+    /** Bundles that conflict with this one (mutually exclusive) */
+    conflicts?: string[];
+    /** Complexity level of the bundle */
+    complexity?: BundleComplexity;
+    /** Detailed information about each module for rich display */
+    moduleDetails?: BundleModuleDetails;
+}
+/**
+ * Bundle selection result
+ */
+interface BundleSelectionResult {
+    /** Selected bundle IDs */
+    selectedBundles: string[];
+    /** Individual modules selected outside bundles */
+    additionalModules: {
+        agents: string[];
+        skills: string[];
+        commands: string[];
+        docs: string[];
+    };
+}
+/**
+ * Resolved bundle with full module definitions
+ */
+interface ResolvedBundle {
+    /** Bundle definition */
+    bundle: BundleDefinition;
+    /** Resolved modules from the bundle */
+    modules: {
+        agents: string[];
+        skills: string[];
+        commands: string[];
+        docs: string[];
+    };
+}
+
+/**
+ * Predefined bundles for grouping related modules
+ */
+
+/**
+ * All available bundles
+ */
+declare const BUNDLES: BundleDefinition[];
+/**
+ * Get all bundles
+ */
+declare function getAllBundles(): BundleDefinition[];
+/**
+ * Get bundle by ID
+ */
+declare function getBundleById(id: string): BundleDefinition | undefined;
+
+/**
+ * MCP Server definitions
+ */
+
+/**
+ * Available MCP servers
+ */
+declare const MCP_SERVERS: McpServerDefinition[];
+
+/**
+ * System dependency types
+ */
+/**
+ * Platform identifiers
+ */
+type Platform = 'linux' | 'macos' | 'windows';
+/**
+ * Installation instructions for a platform
+ */
+interface InstallInstructions {
+    /** Commands to run */
+    commands: string[];
+    /** Additional notes */
+    notes?: string;
+    /** Useful links */
+    links?: string[];
+}
+/**
+ * System dependency information
+ */
+interface DependencyInfo {
+    /** Unique identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Description of what this dependency provides */
+    description: string;
+    /** Features that require this dependency */
+    requiredFor: string[];
+    /** Command to check if installed */
+    checkCommand: string;
+    /** Platform-specific installation instructions */
+    platforms: Partial<Record<Platform, InstallInstructions>>;
+}
+
+/**
+ * System dependency definitions
+ */
+
+/**
+ * System dependencies required for various features
+ */
+declare const DEPENDENCIES: DependencyInfo[];
+
+/**
+ * Placeholder replacement types
+ */
+
+/**
+ * Transformation to apply to placeholder value
+ */
+type PlaceholderTransform = 'none' | 'lowercase' | 'uppercase' | 'capitalize' | 'pluralize';
+/**
+ * Placeholder definition
+ */
+interface PlaceholderDefinition {
+    /** Pattern to find (string or regex) */
+    pattern: string | RegExp;
+    /** Config key to get replacement value */
+    configKey: keyof ProjectInfo;
+    /** Transformation to apply */
+    transform: PlaceholderTransform;
+    /** Description for documentation */
+    description: string;
+    /** Example value */
+    example: string;
+    /** Whether this placeholder is required */
+    required: boolean;
+}
+/**
+ * Single placeholder replacement record
+ */
+interface PlaceholderReplacement {
+    /** File where replacement was made */
+    file: string;
+    /** Line number */
+    line: number;
+    /** Original text */
+    original: string;
+    /** Replacement text */
+    replacement: string;
+    /** Placeholder definition used */
+    placeholder: PlaceholderDefinition;
+}
+/**
+ * Placeholder replacement report
+ */
+interface PlaceholderReport {
+    /** Total files scanned */
+    totalFiles: number;
+    /** Files that were modified */
+    filesModified: number;
+    /** All replacements made */
+    replacements: PlaceholderReplacement[];
+    /** Placeholders that couldn't be replaced (missing values) */
+    unreplacedPlaceholders: string[];
+}
+
+/**
+ * Placeholder definitions for template processing
+ */
+
+/**
+ * All placeholder patterns that can be replaced in templates
+ */
+declare const PLACEHOLDERS: PlaceholderDefinition[];
+
+/**
+ * Permission preset definitions
+ */
+
+/**
+ * All permission presets
+ */
+declare const PERMISSION_PRESETS: Record<PermissionPreset, Omit<PermissionsConfig, 'preset' | 'custom'>>;
+
+/**
+ * Bundle resolver - resolves bundles to individual modules
+ */
+
+/**
+ * Resolve a bundle to its constituent modules
+ */
+declare function resolveBundle(bundle: BundleDefinition): ResolvedBundle;
+/**
+ * Resolve multiple bundles to a combined module selection
+ */
+declare function resolveBundles(bundleIds: string[]): ModuleSelectionResult;
+/**
+ * Merge bundle selection with additional individual modules
+ */
+declare function mergeBundleSelection(bundleResult: BundleSelectionResult): ModuleSelectionResult;
+
+/**
+ * Configuration reader - reads Claude config files
+ */
+
+/**
+ * Read Claude configuration from a project
+ */
+declare function readConfig(projectPath: string): Promise<ClaudeConfig | null>;
+/**
+ * Check if a Claude configuration exists
+ */
+declare function hasConfig(projectPath: string): Promise<boolean>;
+
+/**
+ * Configuration writer - writes Claude config files
+ */
+
+/**
+ * Write Claude configuration
+ */
+declare function writeConfig(projectPath: string, config: ClaudeConfig, options?: {
+    backup?: boolean;
+}): Promise<void>;
+/**
+ * Create a default configuration
+ */
+declare function createDefaultConfig(options: {
+    version: string;
+    projectInfo: ClaudeConfig['project'];
+    preferences: ClaudeConfig['preferences'];
+}): ClaudeConfig;
+
+/**
+ * Module registry - reads and manages module definitions from templates
+ */
+
+/**
+ * Load module registry from a templates directory
+ */
+declare function loadRegistry(templatesPath: string): Promise<ModuleRegistry>;
+
+/**
+ * Module resolver - resolves module dependencies and order
+ */
+
+interface ResolvedModule extends ModuleDefinition {
+    resolvedDependencies: string[];
+    installOrder: number;
+}
+interface ResolutionResult {
+    resolved: ResolvedModule[];
+    unresolved: string[];
+    circular: string[];
+}
+/**
+ * Resolve dependencies for selected modules
+ */
+declare function resolveModules(registry: ModuleRegistry, category: ModuleCategory, selectedIds: string[]): ResolutionResult;
+
+/**
+ * Module installer - copies and configures module files
+ */
+
+interface InstallOptions {
+    templatesPath: string;
+    targetPath: string;
+    overwrite?: boolean;
+    dryRun?: boolean;
+}
+interface InstallResult {
+    success: boolean;
+    installed: string[];
+    skipped: string[];
+    failed: Array<{
+        id: string;
+        error: string;
+    }>;
+}
+/**
+ * Install modules for a category
+ */
+declare function installModules(category: ModuleCategory, modules: ModuleDefinition[], options: InstallOptions): Promise<InstallResult>;
+
+/**
+ * Placeholder replacer - finds and replaces placeholders in files
+ */
+
+/**
+ * Replace placeholders with spinner
+ */
+declare function replacePlaceholders(dirPath: string, projectInfo: ProjectInfo, options?: {
+    extensions?: string[];
+    exclude?: string[];
+    dryRun?: boolean;
+    silent?: boolean;
+}): Promise<PlaceholderReport>;
+
+/**
+ * Project detector - detects existing project type and configuration
+ */
+
+/**
+ * Detect project type and configuration
+ */
+declare function detectProject(projectPath: string): Promise<ProjectDetectionResult>;
+
+/**
+ * Template processing types for dynamic content generation
+ */
+
+/**
+ * Context for template processing
+ */
+interface TemplateContext {
+    /** Project info from config */
+    project: {
+        name?: string;
+        description?: string;
+        org?: string;
+        repo?: string;
+        domain?: string;
+        entityType?: string;
+        location?: string;
+    };
+    /** Selected modules by category */
+    modules: {
+        agents: string[];
+        skills: string[];
+        commands: string[];
+        docs: string[];
+    };
+    /** Code style choices */
+    codeStyle: {
+        formatter?: 'biome' | 'prettier' | 'none';
+        linter?: 'biome' | 'eslint' | 'none';
+        editorConfig?: boolean;
+        commitlint?: boolean;
+    };
+    /** Technology stack choices */
+    techStack: {
+        framework?: string;
+        database?: string;
+        orm?: string;
+        testing?: string;
+        deployment?: string;
+    };
+    /** Bundle selections */
+    bundles: string[];
+    /** MCP servers enabled */
+    mcpServers: string[];
+    /** Custom variables */
+    custom: Record<string, string | boolean | number | string[]>;
+}
+/**
+ * Template processing result
+ */
+interface TemplateResult {
+    /** Processed content */
+    content: string;
+    /** Whether any directives were processed */
+    modified: boolean;
+    /** Directives found and processed */
+    directivesProcessed: number;
+    /** Any warnings during processing */
+    warnings: string[];
+    /** Any errors during processing */
+    errors: string[];
+}
+/**
+ * Template file processing report
+ */
+interface TemplateProcessingReport {
+    /** Files scanned */
+    totalFiles: number;
+    /** Files modified */
+    filesModified: number;
+    /** Total directives processed */
+    totalDirectives: number;
+    /** Files with errors */
+    filesWithErrors: string[];
+    /** All warnings */
+    warnings: string[];
+}
+
+/**
+ * Template processor
+ * Processes templates by evaluating directives and replacing variables
+ */
+
+/**
+ * Process templates with spinner
+ */
+declare function processTemplates(dirPath: string, context: TemplateContext, options?: {
+    extensions?: string[];
+    exclude?: string[];
+    dryRun?: boolean;
+    silent?: boolean;
+}): Promise<TemplateProcessingReport>;
+
+/**
+ * Template context builder
+ * Creates a context object from config and module selections
+ */
+
+/**
+ * Build a template context from config
+ */
+declare function buildTemplateContext(config: Partial<ClaudeConfig>): TemplateContext;
+
+export { BUNDLES, type BundleCategory, type BundleDefinition, type BundleSelectionResult, type ClaudeConfig, type Customizations, DEPENDENCIES, type HookConfig, MCP_SERVERS, type McpCategory, type McpConfigField, type McpInstallation, type McpServerDefinition, type ModuleCategory, type ModuleDefinition, type ModuleRegistry, type ModuleSelection, PERMISSION_PRESETS, PLACEHOLDERS, type PermissionPreset, type PermissionsConfig, type Preferences, type ProjectDetectionResult, type ProjectType, type ResolvedBundle, type ResolvedModule$1 as ResolvedModule, type ScaffoldConfig, type ScaffoldOptions, type ScaffoldResult, type ScaffoldType, type TemplateContext, type TemplateProcessingReport, type TemplateResult, type TemplateSource, buildTemplateContext, createDefaultConfig, detectProject, getAllBundles, getBundleById, hasConfig, installModules, loadRegistry, mergeBundleSelection, processTemplates, readConfig, replacePlaceholders, resolveBundle, resolveBundles, resolveModules, writeConfig };