trinity-method-sdk 2.0.0

package/dist/cli/commands/deploy/index.js

@@ -0,0 +1,156 @@
+/**
+ * Deploy Command - Complete Trinity Method SDK deployment to user projects
+ *
+ * @see docs/workflows/deploy-workflow.md - Complete deployment process
+ * @see docs/deployment/best-practices.md - Deployment best practices
+ *
+ * **Trinity Principle:** "Systematic Quality Assurance"
+ * Deploys complete Trinity Method infrastructure with interactive wizard: creates folder structure,
+ * deploys 18 agent templates, installs slash commands, configures quality tools (ESLint, Prettier),
+ * and sets up CI/CD templates. Ensures every Trinity project starts with proven, consistent foundation.
+ *
+ * **Why This Exists:**
+ * Manual setup is error-prone and inconsistent. Developers forget folders, skip quality tools, or
+ * misconfigure agents. This command orchestrates TAN (structure), ZEN (documentation), INO (context),
+ * and EIN (CI/CD) to deploy battle-tested Trinity infrastructure in minutes. Every project gets same
+ * high-quality foundation: 19 agents, 20 commands, quality gates, and documentation architecture.
+ *
+ * @example
+ * ```bash
+ * # Interactive deployment
+ * npx trinity deploy
+ *
+ * # Non-interactive with defaults
+ * npx trinity deploy --yes
+ *
+ * # Force redeployment
+ * npx trinity deploy --force
+ * ```
+ *
+ * @module cli/commands/deploy
+ */
+import ora from 'ora';
+import chalk from 'chalk';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { readFileSync } from 'fs';
+import { detectStack } from '../../utils/detect-stack.js';
+import { checkPreFlight } from './pre-flight.js';
+import { promptConfiguration } from './configuration.js';
+import { collectMetrics } from './metrics.js';
+import { createDirectories } from './directories.js';
+import { deployKnowledgeBase } from './knowledge-base.js';
+import { deployRootFiles } from './root-files.js';
+import { deployAgents } from './agents.js';
+import { deployClaudeSetup } from './claude-setup.js';
+import { deployLinting } from './linting.js';
+import { deployTemplates } from './templates.js';
+import { deployCICD } from './ci-cd.js';
+import { updateGitignore } from './gitignore.js';
+import { installSDK } from './sdk-install.js';
+import { displaySummary } from './summary.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Deploy Trinity Method SDK to project
+ * @param options - Deployment options
+ */
+export async function deploy(options) {
+    console.log(chalk.blue.bold('\n🔱 Trinity Method SDK - Deployment\n'));
+    const spinner = ora();
+    const progress = {
+        agentsDeployed: 0,
+        commandsDeployed: 0,
+        knowledgeBaseFiles: 0,
+        templatesDeployed: 0,
+        rootFilesDeployed: 0,
+    };
+    try {
+        // STEP 1: Pre-flight checks
+        await checkPreFlight(options, spinner);
+        // STEP 2: Detect technology stack
+        spinner.start('Detecting project technology stack...');
+        const stack = await detectStack();
+        spinner.succeed(`Detected: ${stack.framework} (${stack.language}) - Source: ${stack.sourceDir}`);
+        // STEP 3: Interactive configuration (or use defaults with --yes)
+        const config = await promptConfiguration(options, stack);
+        // STEP 3.5: Collect codebase metrics
+        let metrics;
+        if (!options.skipAudit) {
+            metrics = await collectMetrics(stack, spinner);
+        }
+        else {
+            const { createEmptyMetrics } = await import('../../utils/metrics/index.js');
+            metrics = createEmptyMetrics();
+        }
+        // Prepare template variables
+        // Note: In dist/, this file is at dist/cli/commands/deploy/index.js
+        // Templates are copied to dist/templates, so we go up 3 levels from deploy/
+        const templatesPath = path.join(__dirname, '../../../templates');
+        const pkgPath = path.join(__dirname, '../../../../package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        const variables = {
+            PROJECT_NAME: config.projectName || 'My Project',
+            FRAMEWORK: stack.framework,
+            LANGUAGE: stack.language,
+            SOURCE_DIR: stack.sourceDir,
+            PACKAGE_MANAGER: stack.packageManager || 'npm',
+            BACKEND_FRAMEWORK: stack.framework,
+            CURRENT_DATE: new Date().toISOString(),
+            TRINITY_VERSION: pkg.version || '2.0.0',
+        };
+        // STEP 4: Create directory structure
+        const directoriesCreated = await createDirectories(spinner);
+        progress.directories = directoriesCreated;
+        // STEP 5: Deploy knowledge base templates
+        const kbFiles = await deployKnowledgeBase(templatesPath, variables, stack, metrics, spinner);
+        progress.knowledgeBaseFiles = kbFiles;
+        progress.rootFilesDeployed += kbFiles;
+        // STEP 6: Deploy root files and CLAUDE.md hierarchy
+        const rootFiles = await deployRootFiles(templatesPath, variables, stack, pkg.version, spinner);
+        progress.rootFilesDeployed += rootFiles;
+        // STEP 7: Deploy agent configurations
+        const agentsDeployed = await deployAgents(templatesPath, variables, spinner);
+        progress.agentsDeployed = agentsDeployed;
+        // STEP 9: Deploy Claude Code setup (settings, employee directory, commands)
+        const claudeSetup = await deployClaudeSetup(templatesPath, variables, spinner);
+        progress.commandsDeployed = claudeSetup.commandsDeployed;
+        progress.rootFilesDeployed += claudeSetup.filesDeployed;
+        // STEP 9.7-9.8: Deploy linting configuration (if selected)
+        if (config.lintingTools && config.lintingTools.length > 0) {
+            const lintingFiles = await deployLinting(config.lintingTools, config.lintingDependencies || [], config.lintingScripts || {}, stack, templatesPath, variables, spinner);
+            progress.rootFilesDeployed += lintingFiles;
+        }
+        // STEP 10: Deploy templates (work orders, investigations, documentation)
+        const templatesDeployed = await deployTemplates(templatesPath, variables, spinner);
+        progress.templatesDeployed = templatesDeployed;
+        // STEP 11: Deploy CI/CD workflow templates (if enabled)
+        const cicdFiles = await deployCICD(options, spinner);
+        progress.rootFilesDeployed += cicdFiles;
+        // STEP 11.5: Update .gitignore
+        const gitignoreUpdated = await updateGitignore(spinner);
+        if (gitignoreUpdated) {
+            progress.rootFilesDeployed++;
+        }
+        // STEP 12: Install Trinity Method SDK
+        const sdkInstalled = await installSDK(spinner);
+        if (sdkInstalled) {
+            progress.rootFilesDeployed++;
+        }
+        // SUCCESS: Display deployment summary
+        await displaySummary(progress, options, stack, metrics);
+    }
+    catch (error) {
+        if (spinner)
+            spinner.fail();
+        const { displayError, getErrorMessage } = await import('../../utils/errors.js');
+        const message = getErrorMessage(error);
+        displayError(`Deployment failed: ${message}`);
+        if (message === 'Deployment cancelled by user') {
+            return;
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/cli/commands/deploy/knowledge-base.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Knowledge base template deployment
+ */
+import type { Stack, CodebaseMetrics, Spinner } from './types.js';
+/**
+ * Deploy and enrich knowledge base templates
+ *
+ * @param templatesPath - Path to templates directory
+ * @param variables - Template variables for substitution
+ * @param stack - Detected technology stack
+ * @param metrics - Collected codebase metrics
+ * @param spinner - Spinner instance for status updates
+ * @returns Number of files deployed
+ */
+export declare function deployKnowledgeBase(templatesPath: string, variables: Record<string, string>, stack: Stack, metrics: CodebaseMetrics, spinner: Spinner): Promise<number>;
+//# sourceMappingURL=knowledge-base.d.ts.map

package/dist/cli/commands/deploy/knowledge-base.js

@@ -0,0 +1,75 @@
+/**
+ * Knowledge base template deployment
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import { processTemplate } from '../../utils/template-processor.js';
+import { validatePath } from '../../utils/validate-path.js';
+/**
+ * Deploy and enrich knowledge base templates
+ *
+ * @param templatesPath - Path to templates directory
+ * @param variables - Template variables for substitution
+ * @param stack - Detected technology stack
+ * @param metrics - Collected codebase metrics
+ * @param spinner - Spinner instance for status updates
+ * @returns Number of files deployed
+ */
+export async function deployKnowledgeBase(templatesPath, variables, stack, metrics, spinner) {
+    spinner.start('Deploying knowledge base templates...');
+    let filesDeployed = 0;
+    const kbTemplates = [
+        'ARCHITECTURE.md',
+        'Trinity.md',
+        'To-do.md',
+        'ISSUES.md',
+        'Technical-Debt.md',
+        'CODING-PRINCIPLES.md',
+        'TESTING-PRINCIPLES.md',
+        'AI-DEVELOPMENT-GUIDE.md',
+        'DOCUMENTATION-CRITERIA.md',
+    ];
+    for (const template of kbTemplates) {
+        const templatePath = path.join(templatesPath, 'knowledge-base', `${template}.template`);
+        if (await fs.pathExists(templatePath)) {
+            const content = await fs.readFile(templatePath, 'utf8');
+            const processed = processTemplate(content, variables);
+            // Validate destination path for security
+            const destPath = validatePath(`trinity/knowledge-base/${template}`);
+            await fs.writeFile(destPath, processed);
+            filesDeployed++;
+        }
+    }
+    spinner.succeed('Knowledge base templates deployed');
+    // Enrich knowledge base with project metrics
+    try {
+        spinner.start('Enriching knowledge base with project metrics...');
+        const archPath = 'trinity/knowledge-base/ARCHITECTURE.md';
+        if (await fs.pathExists(archPath)) {
+            let archContent = await fs.readFile(archPath, 'utf8');
+            // Replace common placeholders with actual data
+            archContent = archContent
+                .replace(/\{\{PROJECT_NAME\}\}/g, variables.PROJECT_NAME)
+                .replace(/\{\{FRAMEWORK\}\}/g, stack.framework)
+                .replace(/\{\{LANGUAGE\}\}/g, stack.language)
+                .replace(/\{\{SOURCE_DIR\}\}/g, stack.sourceDir)
+                .replace(/\{\{PACKAGE_MANAGER\}\}/g, stack.packageManager || 'npm')
+                .replace(/\{\{BACKEND_FRAMEWORK\}\}/g, stack.framework)
+                .replace(/\{\{TODO_COUNT\}\}/g, String(metrics?.todoCount || 0))
+                .replace(/\{\{FILE_COUNT\}\}/g, String(metrics?.totalFiles || 0))
+                .replace(/\{\{DEPENDENCY_COUNT\}\}/g, String(metrics?.dependencyCount || 0));
+            // Validate path for security
+            const validatedArchPath = validatePath(archPath);
+            await fs.writeFile(validatedArchPath, archContent);
+            spinner.succeed('Knowledge base enriched with project data');
+        }
+        else {
+            spinner.info('ARCHITECTURE.md not found - skipping enrichment');
+        }
+    }
+    catch {
+        spinner.warn('Knowledge base enrichment skipped');
+    }
+    return filesDeployed;
+}
+//# sourceMappingURL=knowledge-base.js.map

package/dist/cli/commands/deploy/linting.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Linting configuration deployment
+ */
+import type { LintingTool, Stack, Spinner } from './types.js';
+/**
+ * Deploy linting tools and inject dependencies
+ *
+ * @param lintingTools - Selected linting tools to deploy
+ * @param lintingDependencies - Dependencies to inject
+ * @param lintingScripts - Scripts to add to package.json
+ * @param stack - Detected technology stack
+ * @param templatesPath - Path to templates directory
+ * @param variables - Template variables for substitution
+ * @param spinner - Spinner instance for status updates
+ * @returns Number of files deployed
+ */
+export declare function deployLinting(lintingTools: LintingTool[], lintingDependencies: string[], lintingScripts: Record<string, string>, stack: Stack, templatesPath: string, variables: Record<string, string>, spinner: Spinner): Promise<number>;
+//# sourceMappingURL=linting.d.ts.map

package/dist/cli/commands/deploy/linting.js

@@ -0,0 +1,51 @@
+/**
+ * Linting configuration deployment
+ */
+import { deployLintingTool } from '../../utils/deploy-linting.js';
+import { injectLintingDependencies } from '../../utils/inject-dependencies.js';
+/**
+ * Deploy linting tools and inject dependencies
+ *
+ * @param lintingTools - Selected linting tools to deploy
+ * @param lintingDependencies - Dependencies to inject
+ * @param lintingScripts - Scripts to add to package.json
+ * @param stack - Detected technology stack
+ * @param templatesPath - Path to templates directory
+ * @param variables - Template variables for substitution
+ * @param spinner - Spinner instance for status updates
+ * @returns Number of files deployed
+ */
+export async function deployLinting(lintingTools, lintingDependencies, lintingScripts, stack, templatesPath, variables, spinner) {
+    let filesDeployed = 0;
+    // Deploy linting configuration files
+    if (lintingTools.length > 0) {
+        spinner.start('Deploying linting configuration...');
+        try {
+            for (const tool of lintingTools) {
+                await deployLintingTool(tool, stack, templatesPath, variables);
+                filesDeployed++;
+            }
+            spinner.succeed(`Linting configuration deployed (${lintingTools.length} tools)`);
+        }
+        catch (error) {
+            spinner.fail('Linting configuration deployment failed');
+            const { displayWarning, getErrorMessage } = await import('../../utils/errors.js');
+            displayWarning(getErrorMessage(error));
+        }
+    }
+    // Inject linting dependencies
+    if (lintingDependencies.length > 0) {
+        spinner.start('Adding linting dependencies to project...');
+        try {
+            await injectLintingDependencies(lintingDependencies, lintingScripts, stack.framework);
+            spinner.succeed('Linting dependencies added to project configuration');
+        }
+        catch (error) {
+            spinner.fail('Dependency injection failed');
+            const { displayWarning, getErrorMessage } = await import('../../utils/errors.js');
+            displayWarning(getErrorMessage(error));
+        }
+    }
+    return filesDeployed;
+}
+//# sourceMappingURL=linting.js.map

package/dist/cli/commands/deploy/metrics.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Codebase metrics collection for deployment
+ */
+import type { CodebaseMetrics, Stack, Spinner } from './types.js';
+/**
+ * Collect codebase metrics for enriching templates
+ *
+ * @param stack - Detected technology stack
+ * @param spinner - Spinner instance for status updates
+ * @returns Collected codebase metrics
+ */
+export declare function collectMetrics(stack: Stack, spinner: Spinner): Promise<CodebaseMetrics>;
+//# sourceMappingURL=metrics.d.ts.map

package/dist/cli/commands/deploy/metrics.js

@@ -0,0 +1,34 @@
+/**
+ * Codebase metrics collection for deployment
+ */
+import chalk from 'chalk';
+import { collectCodebaseMetrics } from '../../utils/metrics/index.js';
+/**
+ * Collect codebase metrics for enriching templates
+ *
+ * @param stack - Detected technology stack
+ * @param spinner - Spinner instance for status updates
+ * @returns Collected codebase metrics
+ */
+export async function collectMetrics(stack, spinner) {
+    spinner.start('Collecting codebase metrics...');
+    try {
+        const metrics = await collectCodebaseMetrics(stack.sourceDir, stack.framework);
+        spinner.succeed('Codebase metrics collected');
+        // Display metrics summary
+        console.log(chalk.cyan('\n📊 Codebase Metrics:'));
+        console.log(chalk.white(`  Total Files: ${metrics.totalFiles}`));
+        console.log(chalk.white(`  TODO Comments: ${metrics.todoCount}`));
+        console.log(chalk.white(`  Large Files (>500 lines): ${metrics.filesOver500}`));
+        console.log(chalk.white(`  Dependencies: ${metrics.dependencyCount}`));
+        return metrics;
+    }
+    catch {
+        spinner.warn('Could not collect all metrics');
+        console.log(chalk.yellow('  Some metrics collection failed, continuing...'));
+        // Return minimal metrics
+        const { createEmptyMetrics } = await import('../../utils/metrics/index.js');
+        return createEmptyMetrics();
+    }
+}
+//# sourceMappingURL=metrics.js.map

package/dist/cli/commands/deploy/pre-flight.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Pre-flight checks for Trinity deployment
+ */
+import type { DeployOptions, Spinner } from './types.js';
+/**
+ * Check if Trinity is already deployed and handle force flag
+ *
+ * @param options - Deploy command options
+ * @param spinner - Spinner instance for status updates
+ * @throws Error if Trinity already deployed and --force not used
+ */
+export declare function checkPreFlight(options: DeployOptions, spinner: Spinner): Promise<void>;
+//# sourceMappingURL=pre-flight.d.ts.map

package/dist/cli/commands/deploy/pre-flight.js

@@ -0,0 +1,29 @@
+/**
+ * Pre-flight checks for Trinity deployment
+ */
+import fs from 'fs-extra';
+import chalk from 'chalk';
+/**
+ * Check if Trinity is already deployed and handle force flag
+ *
+ * @param options - Deploy command options
+ * @param spinner - Spinner instance for status updates
+ * @throws Error if Trinity already deployed and --force not used
+ */
+export async function checkPreFlight(options, spinner) {
+    spinner.start('Running pre-flight checks...');
+    // Check if Trinity is already deployed
+    const trinityExists = await fs.pathExists('trinity');
+    if (trinityExists && !options.force) {
+        spinner.fail();
+        console.log(chalk.yellow('\nTrinity Method is already deployed in this project.'));
+        console.log(chalk.cyan('\nUse --force flag to redeploy (this will overwrite existing files):'));
+        console.log(chalk.white('  npx trinity deploy --force\n'));
+        throw new Error('Trinity already deployed. Use --force to redeploy.');
+    }
+    if (trinityExists && options.force) {
+        spinner.text = 'Force flag detected - will overwrite existing deployment...';
+    }
+    spinner.succeed('Pre-flight checks passed');
+}
+//# sourceMappingURL=pre-flight.js.map

package/dist/cli/commands/deploy/root-files.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Root files and CLAUDE.md hierarchy deployment
+ */
+import type { Stack, Spinner } from './types.js';
+/**
+ * Deploy root files and CLAUDE.md hierarchy
+ *
+ * @param templatesPath - Path to templates directory
+ * @param variables - Template variables for substitution
+ * @param stack - Detected technology stack
+ * @param pkgVersion - Package version for VERSION file
+ * @param spinner - Spinner instance for status updates
+ * @returns Number of files deployed
+ */
+export declare function deployRootFiles(templatesPath: string, variables: Record<string, string>, stack: Stack, pkgVersion: string, spinner: Spinner): Promise<number>;
+//# sourceMappingURL=root-files.d.ts.map

package/dist/cli/commands/deploy/root-files.js

@@ -0,0 +1,178 @@
+/**
+ * Root files and CLAUDE.md hierarchy deployment
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import { processTemplate } from '../../utils/template-processor.js';
+import { validatePath } from '../../utils/validate-path.js';
+/**
+ * Deploy TRINITY.md root file
+ */
+async function deployTrinityMarkdown(templatesPath, variables) {
+    const trinityRootTemplate = path.join(templatesPath, 'root', 'TRINITY.md.template');
+    if (await fs.pathExists(trinityRootTemplate)) {
+        const content = await fs.readFile(trinityRootTemplate, 'utf8');
+        const processed = processTemplate(content, variables);
+        const destPath = validatePath('TRINITY.md');
+        await fs.writeFile(destPath, processed);
+        return 1;
+    }
+    return 0;
+}
+/**
+ * Deploy root CLAUDE.md file
+ */
+async function deployRootClaudeMarkdown(templatesPath, variables) {
+    const claudeRootTemplate = path.join(templatesPath, 'root', 'CLAUDE.md.template');
+    if (await fs.pathExists(claudeRootTemplate)) {
+        const content = await fs.readFile(claudeRootTemplate, 'utf8');
+        const processed = processTemplate(content, variables);
+        const destPath = validatePath('CLAUDE.md');
+        await fs.writeFile(destPath, processed);
+        return 1;
+    }
+    return 0;
+}
+/**
+ * Deploy VERSION file
+ */
+async function deployVersionFile(pkgVersion) {
+    const versionPath = validatePath('trinity/VERSION');
+    await fs.writeFile(versionPath, pkgVersion || '2.0.0');
+    return 1;
+}
+/**
+ * Deploy trinity/CLAUDE.md file
+ */
+async function deployTrinityClaudeMarkdown(templatesPath, variables, spinner) {
+    spinner.start('Deploying Trinity CLAUDE.md...');
+    const trinityCLAUDETemplate = path.join(templatesPath, 'trinity', 'CLAUDE.md.template');
+    if (await fs.pathExists(trinityCLAUDETemplate)) {
+        const content = await fs.readFile(trinityCLAUDETemplate, 'utf8');
+        const processed = processTemplate(content, variables);
+        const destPath = validatePath('trinity/CLAUDE.md');
+        await fs.writeFile(destPath, processed);
+        spinner.succeed('Trinity CLAUDE.md deployed');
+        return 1;
+    }
+    else {
+        spinner.warn('Trinity CLAUDE.md template not found');
+        return 0;
+    }
+}
+/**
+ * Deploy source directory CLAUDE.md files
+ */
+async function deploySourceClaudeMarkdown(templatesPath, variables, stack, spinner) {
+    const frameworkMap = {
+        'Node.js': 'nodejs-CLAUDE.md.template',
+        Flutter: 'flutter-CLAUDE.md.template',
+        React: 'react-CLAUDE.md.template',
+        'Next.js': 'react-CLAUDE.md.template',
+        Python: 'python-CLAUDE.md.template',
+        Rust: 'rust-CLAUDE.md.template',
+        Unknown: 'base-CLAUDE.md.template',
+    };
+    const templateName = frameworkMap[stack.framework] || 'base-CLAUDE.md.template';
+    let sourceCLAUDETemplate = path.join(templatesPath, 'source', templateName);
+    if (!(await fs.pathExists(sourceCLAUDETemplate))) {
+        console.log(chalk.yellow(`   Note: Using base template for ${stack.framework}`));
+        sourceCLAUDETemplate = path.join(templatesPath, 'source', 'base-CLAUDE.md.template');
+    }
+    if (!(await fs.pathExists(sourceCLAUDETemplate))) {
+        spinner.warn(`Source CLAUDE.md template not found for ${stack.framework}`);
+        return 0;
+    }
+    const content = await fs.readFile(sourceCLAUDETemplate, 'utf8');
+    let deployedCount = 0;
+    for (const sourceDir of stack.sourceDirs) {
+        spinner.start(`Deploying ${sourceDir}/CLAUDE.md...`);
+        if (await fs.pathExists(sourceDir)) {
+            const processed = processTemplate(content, { ...variables, SOURCE_DIR: sourceDir });
+            const destPath = validatePath(`${sourceDir}/CLAUDE.md`);
+            await fs.writeFile(destPath, processed);
+            deployedCount++;
+            spinner.succeed(`${sourceDir}/CLAUDE.md deployed`);
+        }
+        else {
+            spinner.warn(`Directory ${sourceDir} not found, skipping`);
+        }
+    }
+    if (deployedCount === 0) {
+        spinner.warn('No source directories found for CLAUDE.md deployment');
+    }
+    return deployedCount;
+}
+/**
+ * Detect test framework from package.json
+ */
+async function detectTestFramework() {
+    if (!(await fs.pathExists('package.json'))) {
+        return 'Generic';
+    }
+    const pkg = JSON.parse(await fs.readFile('package.json', 'utf8'));
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (allDeps.jest)
+        return 'Jest';
+    if (allDeps.vitest)
+        return 'Vitest';
+    if (allDeps.mocha)
+        return 'Mocha';
+    if (allDeps.pytest)
+        return 'Pytest';
+    return 'Generic';
+}
+/**
+ * Deploy tests/CLAUDE.md file
+ */
+async function deployTestsClaudeMarkdown(templatesPath, variables, spinner) {
+    const testsCLAUDETemplate = path.join(templatesPath, 'source', 'tests-CLAUDE.md.template');
+    if (!(await fs.pathExists(testsCLAUDETemplate))) {
+        if (await fs.pathExists('tests')) {
+            spinner.warn('tests/CLAUDE.md template not found');
+        }
+        return 0;
+    }
+    if (!(await fs.pathExists('tests'))) {
+        return 0;
+    }
+    spinner.start('Deploying tests/CLAUDE.md...');
+    const testsContent = await fs.readFile(testsCLAUDETemplate, 'utf8');
+    const testFramework = await detectTestFramework();
+    const testsProcessed = processTemplate(testsContent, {
+        ...variables,
+        TEST_FRAMEWORK: testFramework,
+    });
+    const destPath = validatePath('tests/CLAUDE.md');
+    await fs.writeFile(destPath, testsProcessed);
+    spinner.succeed('tests/CLAUDE.md deployed');
+    return 1;
+}
+/**
+ * Deploy root files and CLAUDE.md hierarchy
+ *
+ * @param templatesPath - Path to templates directory
+ * @param variables - Template variables for substitution
+ * @param stack - Detected technology stack
+ * @param pkgVersion - Package version for VERSION file
+ * @param spinner - Spinner instance for status updates
+ * @returns Number of files deployed
+ */
+export async function deployRootFiles(templatesPath, variables, stack, pkgVersion, spinner) {
+    let filesDeployed = 0;
+    // Deploy root files
+    spinner.start('Creating root files...');
+    filesDeployed += await deployTrinityMarkdown(templatesPath, variables);
+    filesDeployed += await deployRootClaudeMarkdown(templatesPath, variables);
+    filesDeployed += await deployVersionFile(pkgVersion);
+    spinner.succeed('Root files created');
+    // Deploy trinity/CLAUDE.md
+    filesDeployed += await deployTrinityClaudeMarkdown(templatesPath, variables, spinner);
+    // Deploy source directory CLAUDE.md files
+    filesDeployed += await deploySourceClaudeMarkdown(templatesPath, variables, stack, spinner);
+    // Deploy tests/CLAUDE.md
+    filesDeployed += await deployTestsClaudeMarkdown(templatesPath, variables, spinner);
+    return filesDeployed;
+}
+//# sourceMappingURL=root-files.js.map

package/dist/cli/commands/deploy/sdk-install.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Trinity Method SDK installation
+ */
+import type { Spinner } from './types.js';
+/**
+ * Install Trinity Method SDK to the project
+ *
+ * @param spinner - Spinner instance for status updates
+ * @returns True if SDK was installed, false otherwise
+ */
+export declare function installSDK(spinner: Spinner): Promise<boolean>;
+//# sourceMappingURL=sdk-install.d.ts.map