trinity-method-sdk 2.0.0

package/dist/cli/commands/deploy/sdk-install.js

@@ -0,0 +1,57 @@
+/**
+ * Trinity Method SDK installation
+ */
+import fs from 'fs-extra';
+import chalk from 'chalk';
+/**
+ * Install Trinity Method SDK to the project
+ *
+ * @param spinner - Spinner instance for status updates
+ * @returns True if SDK was installed, false otherwise
+ */
+export async function installSDK(spinner) {
+    spinner.start('Installing Trinity Method SDK...');
+    try {
+        const { execSync } = await import('child_process');
+        const packageJsonPath = 'package.json';
+        if (await fs.pathExists(packageJsonPath)) {
+            // Check if SDK is already installed
+            const packageJson = await fs.readJson(packageJsonPath);
+            const hasSDK = packageJson.dependencies?.['trinity-method-sdk'] ||
+                packageJson.devDependencies?.['trinity-method-sdk'];
+            if (!hasSDK) {
+                // Add SDK to package.json dependencies
+                if (!packageJson.dependencies) {
+                    packageJson.dependencies = {};
+                }
+                packageJson.dependencies['trinity-method-sdk'] = '^2.0.0';
+                await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+                spinner.text = 'Installing Trinity Method SDK (this may take a moment)...';
+                // Install dependencies
+                execSync('npm install', {
+                    stdio: 'pipe',
+                    cwd: process.cwd(),
+                });
+                spinner.succeed('Trinity Method SDK installed successfully');
+                return true;
+            }
+            else {
+                spinner.info('Trinity Method SDK already installed');
+                return false;
+            }
+        }
+        else {
+            spinner.warn('No package.json found - SDK not installed');
+            console.log(chalk.yellow('   Run: npm init -y && npm install trinity-method-sdk'));
+            return false;
+        }
+    }
+    catch (error) {
+        spinner.warn('SDK installation skipped');
+        const { getErrorMessage } = await import('../../utils/errors.js');
+        console.log(chalk.yellow(`   Install manually: npm install trinity-method-sdk`));
+        console.log(chalk.gray(`   Error: ${getErrorMessage(error)}`));
+        return false;
+    }
+}
+//# sourceMappingURL=sdk-install.js.map

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

@@ -0,0 +1,14 @@
+/**
+ * Deployment summary display
+ */
+import type { DeployOptions, Stack, CodebaseMetrics, DeploymentProgress } from './types.js';
+/**
+ * Display deployment summary with statistics and next steps
+ *
+ * @param stats - Deployment progress statistics
+ * @param options - Deploy command options
+ * @param stack - Detected technology stack
+ * @param metrics - Collected codebase metrics
+ */
+export declare function displaySummary(stats: DeploymentProgress, options: DeployOptions, stack: Stack, metrics: CodebaseMetrics): Promise<void>;
+//# sourceMappingURL=summary.d.ts.map

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

@@ -0,0 +1,130 @@
+/**
+ * Deployment summary display
+ */
+import fs from 'fs-extra';
+import chalk from 'chalk';
+/**
+ * Display deployment statistics section
+ */
+function displayStatistics(stats, stack, claudeMdCount, claudeMdSummary) {
+    console.log(chalk.cyan('📊 Deployment Statistics (v2.0):\n'));
+    console.log(chalk.white(`   Directories Created: ${stats.directories || 17}`));
+    console.log(chalk.white(`   Agents Deployed: ${stats.agentsDeployed} (v2.0: 2 leadership + 4 planning + 7 execution + 4 deployment + 1 audit)`));
+    console.log(chalk.white(`   Best Practices: 4 documents (CODING, TESTING, AI-DEV, DOCS)`));
+    console.log(chalk.white(`   Templates Deployed: ${stats.templatesDeployed} (6 work orders)`));
+    console.log(chalk.white(`   Files Created: ${stats.rootFilesDeployed}`));
+    console.log(chalk.white(`   CLAUDE.md Files: ${claudeMdCount} (${claudeMdSummary})`));
+    const totalComponents = (stats.directories || 17) +
+        stats.agentsDeployed +
+        stats.templatesDeployed +
+        stats.rootFilesDeployed;
+    console.log(chalk.white(`   Total Components: ${totalComponents}`));
+    console.log('');
+}
+/**
+ * Display codebase metrics section
+ */
+function displayMetrics(options, metrics) {
+    if (!options.skipAudit && metrics.totalFiles > 0) {
+        console.log(chalk.cyan('🔍 Codebase Metrics:'));
+        console.log(chalk.white(`   Files Analyzed: ${metrics.totalFiles}`));
+        console.log(chalk.white(`   Technical Debt Items: ${metrics.todoCount}`));
+        console.log(chalk.white(`   Large Files (>500 lines): ${metrics.filesOver500}`));
+        console.log(chalk.white(`   Dependencies: ${metrics.dependencyCount}`));
+        console.log(chalk.yellow('\n   Note: Advanced metrics require agent analysis'));
+        console.log(chalk.blue('   Complete deployment with knowledge base agent:'));
+        console.log(chalk.white('   /trinity-zen'));
+        console.log(chalk.white('   (Completes ARCHITECTURE.md and Technical-Debt.md with semantic analysis)\n'));
+    }
+    else if (options.skipAudit) {
+        console.log(chalk.yellow('⚠️  Audit skipped - documents contain placeholders'));
+        console.log(chalk.blue('   Deploy agents to complete documentation\n'));
+    }
+}
+/**
+ * Display quick start commands section
+ */
+function displayQuickStartCommands() {
+    console.log(chalk.cyan('📚 Quick Start Commands:\n'));
+    console.log(chalk.white('  /trinity-init         ') +
+        chalk.gray('- Complete Trinity integration (run first!)'));
+    console.log(chalk.white('  /trinity-verify       ') + chalk.gray('- Verify installation'));
+    console.log(chalk.white('  /trinity-start        ') + chalk.gray('- Start a workflow'));
+    console.log(chalk.white('\n  🤖 v2.0 AI Orchestration:'));
+    console.log(chalk.white('  /trinity-orchestrate  ') +
+        chalk.gray('- AI-orchestrated implementation (AJ MAESTRO)'));
+    console.log(chalk.white('  /trinity-requirements ') + chalk.gray('- Analyze requirements (MON)'));
+    console.log(chalk.white('  /trinity-design       ') + chalk.gray('- Create technical design (ROR)'));
+    console.log(chalk.white('  /trinity-plan         ') + chalk.gray('- Plan implementation (TRA)'));
+    console.log(chalk.white('  /trinity-decompose    ') + chalk.gray('- Decompose into atomic tasks (EUS)'));
+    console.log(chalk.white('\n  📋 Legacy Commands:'));
+    console.log(chalk.white('  /trinity-workorder    ') + chalk.gray('- Create a work order'));
+    console.log(chalk.white('  /trinity-agents       ') + chalk.gray('- View agent directory'));
+    console.log(chalk.white('  /trinity-continue     ') + chalk.gray('- Resume after interruption'));
+    console.log(chalk.white('  /trinity-end          ') + chalk.gray('- End session & archive\n'));
+    console.log(chalk.yellow('💡 Tip: ') +
+        chalk.white('Run /trinity-init, then use /trinity-orchestrate for AI-powered implementation\n'));
+}
+/**
+ * Display next steps section
+ */
+function displayNextSteps(options, stack) {
+    console.log(chalk.cyan('📚 Next Steps:\n'));
+    let step = 1;
+    // Linting dependencies installation
+    if (options.lintingDependencies && options.lintingDependencies.length > 0) {
+        console.log(chalk.white(`   ${step}. Install linting dependencies:`));
+        const installCmd = stack.framework === 'Python' ? 'pip install -r requirements-dev.txt' : 'npm install';
+        console.log(chalk.yellow(`      ${installCmd}\n`));
+        step++;
+    }
+    // Pre-commit hooks setup
+    if (options.postInstallInstructions && options.postInstallInstructions.length > 0) {
+        console.log(chalk.white(`   ${step}. Setup pre-commit hooks (one-time):`));
+        options.postInstallInstructions.forEach((instruction) => {
+            console.log(chalk.yellow(`      ${instruction.command}`));
+        });
+        console.log('');
+        step++;
+    }
+    // Standard next steps
+    console.log(chalk.white(`   ${step}. Review trinity/knowledge-base/ARCHITECTURE.md`));
+    console.log(chalk.white(`   ${step + 1}. Update trinity/knowledge-base/To-do.md`));
+    console.log(chalk.white(`   ${step + 2}. Open Claude Code and start your first Trinity session`));
+    console.log(chalk.white(`   ${step + 3}. Agents will be automatically invoked as needed\n`));
+    // Test linting command (if applicable)
+    if (options.lintingScripts && Object.keys(options.lintingScripts).length > 0) {
+        console.log(chalk.cyan('🧪 Test Linting:\n'));
+        console.log(chalk.white('   After installing dependencies, try:'));
+        Object.keys(options.lintingScripts).forEach((scriptName) => {
+            console.log(chalk.yellow(`      npm run ${scriptName}`));
+        });
+        console.log('');
+    }
+}
+/**
+ * Display deployment summary with statistics and next steps
+ *
+ * @param stats - Deployment progress statistics
+ * @param options - Deploy command options
+ * @param stack - Detected technology stack
+ * @param metrics - Collected codebase metrics
+ */
+export async function displaySummary(stats, options, stack, metrics) {
+    console.log(chalk.green.bold('\n✅ Trinity Method deployed successfully!\n'));
+    // Calculate CLAUDE.md deployment summary
+    const hasTests = await fs.pathExists('tests/CLAUDE.md');
+    const claudeMdCount = 2 + stack.sourceDirs.length + (hasTests ? 1 : 0);
+    const sourceDirsList = stack.sourceDirs.length > 3
+        ? `${stack.sourceDirs.slice(0, 3).join(', ')}... (${stack.sourceDirs.length} total)`
+        : stack.sourceDirs.join(', ');
+    const claudeMdSummary = hasTests
+        ? `root + trinity + tests + ${sourceDirsList}`
+        : `root + trinity + ${sourceDirsList}`;
+    // Display all sections
+    displayStatistics(stats, stack, claudeMdCount, claudeMdSummary);
+    displayMetrics(options, metrics);
+    displayQuickStartCommands();
+    displayNextSteps(options, stack);
+}
+//# sourceMappingURL=summary.js.map

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

@@ -0,0 +1,14 @@
+/**
+ * Template deployment (work orders, investigations, documentation)
+ */
+import type { Spinner } from './types.js';
+/**
+ * Deploy work order, investigation, and documentation templates
+ *
+ * @param templatesPath - Path to templates directory
+ * @param variables - Template variables for substitution
+ * @param spinner - Spinner instance for status updates
+ * @returns Number of templates deployed
+ */
+export declare function deployTemplates(templatesPath: string, variables: Record<string, string>, spinner: Spinner): Promise<number>;
+//# sourceMappingURL=templates.d.ts.map

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

@@ -0,0 +1,84 @@
+/**
+ * Template deployment (work orders, investigations, documentation)
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import { processTemplate } from '../../utils/template-processor.js';
+import { validatePath } from '../../utils/validate-path.js';
+/**
+ * Deploy work order, investigation, and documentation templates
+ *
+ * @param templatesPath - Path to templates directory
+ * @param variables - Template variables for substitution
+ * @param spinner - Spinner instance for status updates
+ * @returns Number of templates deployed
+ */
+export async function deployTemplates(templatesPath, variables, spinner) {
+    let templatesDeployed = 0;
+    // Deploy work order templates
+    spinner.start('Deploying work order templates...');
+    const woTemplates = [
+        'INVESTIGATION-TEMPLATE.md.template',
+        'IMPLEMENTATION-TEMPLATE.md.template',
+        'ANALYSIS-TEMPLATE.md.template',
+        'AUDIT-TEMPLATE.md.template',
+        'PATTERN-TEMPLATE.md.template',
+        'VERIFICATION-TEMPLATE.md.template',
+    ];
+    await fs.ensureDir('trinity/templates/work-orders');
+    for (const template of woTemplates) {
+        const templatePath = path.join(templatesPath, 'work-orders', template);
+        if (await fs.pathExists(templatePath)) {
+            const content = await fs.readFile(templatePath, 'utf8');
+            const processed = processTemplate(content, variables);
+            const deployedName = template.replace('.template', '');
+            // Validate destination path for security
+            const destPath = validatePath(`trinity/templates/work-orders/${deployedName}`);
+            await fs.writeFile(destPath, processed);
+            templatesDeployed++;
+        }
+    }
+    spinner.succeed(`Work order templates deployed (${woTemplates.length} templates)`);
+    // Deploy investigation templates
+    spinner.start('Deploying investigation templates...');
+    const investigationTemplates = [
+        'bug.md.template',
+        'feature.md.template',
+        'performance.md.template',
+        'security.md.template',
+        'technical.md.template',
+    ];
+    await fs.ensureDir('trinity/templates/investigations');
+    for (const template of investigationTemplates) {
+        const templatePath = path.join(templatesPath, 'investigations', template);
+        if (await fs.pathExists(templatePath)) {
+            const content = await fs.readFile(templatePath, 'utf8');
+            const processed = processTemplate(content, variables);
+            const deployedName = template.replace('.template', '');
+            // Validate destination path for security
+            const destPath = validatePath(`trinity/templates/investigations/${deployedName}`);
+            await fs.writeFile(destPath, processed);
+            templatesDeployed++;
+        }
+    }
+    spinner.succeed(`Investigation templates deployed (${investigationTemplates.length} templates)`);
+    // Deploy documentation templates
+    spinner.start('Deploying documentation templates...');
+    const documentationTemplates = ['ROOT-README.md.template', 'SUBDIRECTORY-README.md.template'];
+    await fs.ensureDir('trinity/templates/documentation');
+    for (const template of documentationTemplates) {
+        const templatePath = path.join(templatesPath, 'documentation', template);
+        if (await fs.pathExists(templatePath)) {
+            const content = await fs.readFile(templatePath, 'utf8');
+            const processed = processTemplate(content, variables);
+            const deployedName = template.replace('.template', '');
+            // Validate destination path for security
+            const destPath = validatePath(`trinity/templates/documentation/${deployedName}`);
+            await fs.writeFile(destPath, processed);
+            templatesDeployed++;
+        }
+    }
+    spinner.succeed(`Documentation templates deployed (${documentationTemplates.length} templates)`);
+    return templatesDeployed;
+}
+//# sourceMappingURL=templates.js.map

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

@@ -0,0 +1,39 @@
+/**
+ * Shared types for deploy command modules
+ */
+import type { Ora } from 'ora';
+import type { DeployOptions, Stack, CodebaseMetrics, LintingTool, PostInstallInstruction } from '../../types.js';
+export type { DeployOptions, Stack, CodebaseMetrics, LintingTool, PostInstallInstruction };
+/**
+ * Configuration collected during deploy setup
+ */
+export interface DeployConfig {
+    projectName: string;
+    stack: Stack;
+    metrics: CodebaseMetrics;
+    lintingTools: LintingTool[];
+    lintingDependencies: string[];
+    lintingScripts: Record<string, string>;
+    postInstallInstructions: PostInstallInstruction[];
+    enableLinting: boolean;
+    enableCICD: boolean;
+    enableWorkOrders: boolean;
+    enableInvestigations: boolean;
+    enableDocs: boolean;
+}
+/**
+ * Statistics tracked during deployment
+ */
+export interface DeploymentProgress {
+    directories?: number;
+    agentsDeployed: number;
+    commandsDeployed: number;
+    knowledgeBaseFiles: number;
+    templatesDeployed: number;
+    rootFilesDeployed: number;
+}
+/**
+ * Shared spinner instance passed between modules
+ */
+export type Spinner = Ora;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,5 @@
+/**
+ * Shared types for deploy command modules
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/cli/commands/update/agents.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Update Agents Module
+ * Handles updating agent files in .claude/agents/
+ * @module cli/commands/update/agents
+ */
+import { Ora } from 'ora';
+import { UpdateStats } from './types.js';
+/**
+ * Update agent files from SDK to .claude/agents/
+ * @param spinner - ora spinner instance for status display
+ * @param stats - update statistics to track progress
+ */
+export declare function updateAgents(spinner: Ora, stats: UpdateStats): Promise<void>;
+//# sourceMappingURL=agents.d.ts.map

package/dist/cli/commands/update/agents.js

@@ -0,0 +1,31 @@
+/**
+ * Update Agents Module
+ * Handles updating agent files in .claude/agents/
+ * @module cli/commands/update/agents
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import { getSDKPath } from './utils.js';
+/** Agent subdirectories to update */
+const AGENT_DIRS = ['leadership', 'planning', 'aj-team', 'deployment', 'audit'];
+/**
+ * Update agent files from SDK to .claude/agents/
+ * @param spinner - ora spinner instance for status display
+ * @param stats - update statistics to track progress
+ */
+export async function updateAgents(spinner, stats) {
+    spinner.start('Updating agents...');
+    const sdkPath = await getSDKPath();
+    const agentsTemplatePath = path.join(sdkPath, 'dist/templates/agents');
+    for (const agentDir of AGENT_DIRS) {
+        const sourcePath = path.join(agentsTemplatePath, agentDir);
+        const targetPath = path.join('.claude/agents', agentDir);
+        if (await fs.pathExists(sourcePath)) {
+            await fs.copy(sourcePath, targetPath, { overwrite: true });
+            const files = await fs.readdir(sourcePath);
+            stats.agentsUpdated += files.length;
+        }
+    }
+    spinner.succeed(`Agents updated (${stats.agentsUpdated} files)`);
+}
+//# sourceMappingURL=agents.js.map

package/dist/cli/commands/update/backup.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Update Backup Module
+ * Handles backup creation and rollback operations
+ * @module cli/commands/update/backup
+ */
+import { Ora } from 'ora';
+/**
+ * Create backup of Trinity Method files before update
+ * @param spinner - ora spinner instance for status display
+ * @returns Path to backup directory
+ */
+export declare function createUpdateBackup(spinner: Ora): Promise<string>;
+/**
+ * Restore user-managed content from backup
+ * @param backupDir - Path to backup directory
+ * @param spinner - ora spinner instance for status display
+ */
+export declare function restoreUserContent(backupDir: string, spinner: Ora): Promise<void>;
+/**
+ * Rollback from backup in case of update failure
+ * @param backupDir - Path to backup directory
+ * @throws {Error} If rollback fails
+ */
+export declare function rollbackFromBackup(backupDir: string): Promise<void>;
+/**
+ * Cleanup backup directory after successful update
+ * @param backupDir - Path to backup directory
+ * @param spinner - ora spinner instance for status display
+ */
+export declare function cleanupBackup(backupDir: string, spinner: Ora): Promise<void>;
+//# sourceMappingURL=backup.d.ts.map

package/dist/cli/commands/update/backup.js

@@ -0,0 +1,97 @@
+/**
+ * Update Backup Module
+ * Handles backup creation and rollback operations
+ * @module cli/commands/update/backup
+ */
+import fs from 'fs-extra';
+import path from 'path';
+/** User-managed files that need backup */
+const USER_FILES = [
+    'trinity/knowledge-base/ARCHITECTURE.md',
+    'trinity/knowledge-base/To-do.md',
+    'trinity/knowledge-base/ISSUES.md',
+    'trinity/knowledge-base/Technical-Debt.md',
+];
+/**
+ * Create backup of Trinity Method files before update
+ * @param spinner - ora spinner instance for status display
+ * @returns Path to backup directory
+ */
+export async function createUpdateBackup(spinner) {
+    spinner.start('Creating backup...');
+    const backupDir = `.trinity-backup-${Date.now()}`;
+    await fs.ensureDir(backupDir);
+    // Backup user-managed files
+    for (const file of USER_FILES) {
+        if (await fs.pathExists(file)) {
+            const backupPath = path.join(backupDir, path.basename(file));
+            await fs.copy(file, backupPath);
+        }
+    }
+    // Backup entire trinity and .claude dirs for rollback safety
+    await fs.copy('trinity', path.join(backupDir, 'trinity'));
+    await fs.copy('.claude', path.join(backupDir, '.claude'));
+    spinner.succeed('Backup created');
+    return backupDir;
+}
+/**
+ * Restore user-managed content from backup
+ * @param backupDir - Path to backup directory
+ * @param spinner - ora spinner instance for status display
+ */
+export async function restoreUserContent(backupDir, spinner) {
+    spinner.start('Restoring user content...');
+    for (const file of USER_FILES) {
+        const backupFile = path.join(backupDir, path.basename(file));
+        if (await fs.pathExists(backupFile)) {
+            await fs.copy(backupFile, file, { overwrite: true });
+        }
+    }
+    spinner.succeed('User content restored');
+}
+/**
+ * Rollback from backup in case of update failure
+ * @param backupDir - Path to backup directory
+ * @throws {Error} If rollback fails
+ */
+export async function rollbackFromBackup(backupDir) {
+    if (!(await fs.pathExists(backupDir))) {
+        return; // No backup to rollback from
+    }
+    const rollbackSpinner = await import('ora').then((m) => m.default('Restoring from backup...').start());
+    try {
+        // Restore trinity directory
+        if (await fs.pathExists(path.join(backupDir, 'trinity'))) {
+            await fs.remove('trinity');
+            await fs.copy(path.join(backupDir, 'trinity'), 'trinity');
+        }
+        // Restore .claude directory
+        if (await fs.pathExists(path.join(backupDir, '.claude'))) {
+            await fs.remove('.claude');
+            await fs.copy(path.join(backupDir, '.claude'), '.claude');
+        }
+        // Cleanup backup
+        await fs.remove(backupDir);
+        rollbackSpinner.succeed('Rollback complete - Original state restored');
+        console.log('');
+    }
+    catch (rollbackError) {
+        rollbackSpinner.fail('Rollback failed');
+        const { displayError, displayWarning, displayInfo, getErrorMessage } = await import('../../utils/errors.js');
+        displayError(`CRITICAL: Rollback failed: ${getErrorMessage(rollbackError)}`);
+        displayWarning(`Backup preserved at: ${backupDir}`);
+        displayInfo('Manually restore from backup if needed');
+        throw rollbackError;
+    }
+}
+/**
+ * Cleanup backup directory after successful update
+ * @param backupDir - Path to backup directory
+ * @param spinner - ora spinner instance for status display
+ */
+export async function cleanupBackup(backupDir, spinner) {
+    spinner.start('Cleaning up...');
+    await fs.remove(backupDir);
+    spinner.succeed('Cleanup complete');
+}
+//# sourceMappingURL=backup.js.map

package/dist/cli/commands/update/commands.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Update Commands Module
+ * Handles updating slash command files in .claude/commands/
+ * @module cli/commands/update/commands
+ */
+import { Ora } from 'ora';
+import { UpdateStats } from './types.js';
+/**
+ * Update slash command files from SDK to .claude/commands/
+ * @param spinner - ora spinner instance for status display
+ * @param stats - update statistics to track progress
+ */
+export declare function updateCommands(spinner: Ora, stats: UpdateStats): Promise<void>;
+//# sourceMappingURL=commands.d.ts.map

package/dist/cli/commands/update/commands.js

@@ -0,0 +1,75 @@
+/**
+ * Update Commands Module
+ * Handles updating slash command files in .claude/commands/
+ * @module cli/commands/update/commands
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import { getSDKPath } from './utils.js';
+/** Command categories */
+const COMMAND_CATEGORIES = [
+    'session',
+    'planning',
+    'execution',
+    'investigation',
+    'infrastructure',
+    'utility',
+];
+/**
+ * Determine command category based on filename
+ * @param filename - Command file name
+ * @returns Category name
+ */
+function determineCommandCategory(filename) {
+    if (filename.includes('start') || filename.includes('continue') || filename.includes('end')) {
+        return 'session';
+    }
+    else if (filename.includes('requirements') ||
+        filename.includes('design') ||
+        filename.includes('plan') ||
+        filename.includes('decompose')) {
+        return 'planning';
+    }
+    else if (filename.includes('orchestrate')) {
+        return 'execution';
+    }
+    else if (filename.includes('investigation')) {
+        return 'investigation';
+    }
+    else if (filename.includes('init')) {
+        return 'infrastructure';
+    }
+    return 'utility';
+}
+/**
+ * Update slash command files from SDK to .claude/commands/
+ * @param spinner - ora spinner instance for status display
+ * @param stats - update statistics to track progress
+ */
+export async function updateCommands(spinner, stats) {
+    spinner.start('Updating slash commands...');
+    const sdkPath = await getSDKPath();
+    const commandsTemplatePath = path.join(sdkPath, 'dist/templates/shared/claude-commands');
+    if (!(await fs.pathExists(commandsTemplatePath))) {
+        spinner.warn('Commands template path not found, skipping');
+        return;
+    }
+    // Create command category directories
+    for (const category of COMMAND_CATEGORIES) {
+        const targetCategoryPath = path.join('.claude/commands', category);
+        await fs.ensureDir(targetCategoryPath);
+    }
+    // Copy all command files
+    const commandFiles = await fs.readdir(commandsTemplatePath);
+    for (const file of commandFiles) {
+        if (file.endsWith('.md')) {
+            const sourcePath = path.join(commandsTemplatePath, file);
+            const category = determineCommandCategory(file);
+            const targetPath = path.join('.claude/commands', category, file);
+            await fs.copy(sourcePath, targetPath, { overwrite: true });
+            stats.commandsUpdated++;
+        }
+    }
+    spinner.succeed(`Slash commands updated (${stats.commandsUpdated} files)`);
+}
+//# sourceMappingURL=commands.js.map

package/dist/cli/commands/update/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Update Command - Orchestrator
+ * Coordinates update process with focused helper functions
+ * @see docs/workflows/update-workflow.md
+ * **Trinity Principle:** "Systematic Quality Assurance" - Keep deployment current
+ * @module cli/commands/update
+ */
+import { UpdateOptions } from '../../types.js';
+/**
+ * Update Trinity Method SDK deployment to latest version
+ * Orchestrates the update process with focused helper functions
+ * @param options - Update command options
+ */
+export declare function update(options: UpdateOptions): Promise<void>;
+//# sourceMappingURL=index.d.ts.map