trinity-method-sdk 2.0.0

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

@@ -0,0 +1,118 @@
+/**
+ * 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 ora from 'ora';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { runUpdatePreflightChecks } from './pre-flight.js';
+import { detectInstalledSDKVersion } from './version.js';
+import { createUpdateBackup, restoreUserContent, rollbackFromBackup, cleanupBackup, } from './backup.js';
+import { updateAgents } from './agents.js';
+import { updateCommands } from './commands.js';
+import { updateTemplates } from './templates.js';
+import { updateKnowledgeBase } from './knowledge-base.js';
+import { verifyUpdateDeployment, updateVersionFile } from './verification.js';
+import { displayUpdateSummary, displayDryRunPreview } from './summary.js';
+import { UpdateError } from '../../utils/error-classes.js';
+import { errorHandler } from '../../utils/error-handler.js';
+/**
+ * Update Trinity Method SDK deployment to latest version
+ * Orchestrates the update process with focused helper functions
+ * @param options - Update command options
+ */
+export async function update(options) {
+    console.log(chalk.blue.bold('\n🔄 Trinity Method SDK - Update\n'));
+    const spinner = ora();
+    let backupDir = null;
+    const stats = {
+        agentsUpdated: 0,
+        templatesUpdated: 0,
+        knowledgeBaseUpdated: 0,
+        commandsUpdated: 0,
+        filesUpdated: 0,
+    };
+    try {
+        // STEP 1: Pre-flight checks
+        await runUpdatePreflightChecks(spinner);
+        // STEP 2: Version check
+        const versionInfo = await detectInstalledSDKVersion(spinner);
+        if (versionInfo.isUpToDate) {
+            console.log(chalk.green('✅ Already up to date\n'));
+            return;
+        }
+        // STEP 3: Dry-run preview or confirmation
+        if (options.dryRun) {
+            displayDryRunPreview(versionInfo.currentVersion, versionInfo.latestVersion);
+            return;
+        }
+        const { confirm } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: `Update Trinity Method from ${versionInfo.currentVersion} to ${versionInfo.latestVersion}?`,
+                default: true,
+            },
+        ]);
+        if (!confirm) {
+            console.log(chalk.yellow('Update cancelled\n'));
+            return;
+        }
+        // STEP 4: Create backup
+        backupDir = await createUpdateBackup(spinner);
+        // Register cleanup for backup directory
+        errorHandler.registerCleanup('Remove backup directory', async () => {
+            if (backupDir) {
+                await cleanupBackup(backupDir, ora());
+            }
+        });
+        // STEP 5-8: Update components
+        await updateAgents(spinner, stats);
+        await updateCommands(spinner, stats);
+        await updateTemplates(spinner, stats);
+        await updateKnowledgeBase(spinner, stats);
+        // STEP 9: Restore user content
+        await restoreUserContent(backupDir, spinner);
+        // STEP 10: Update VERSION file
+        await updateVersionFile(spinner, versionInfo.latestVersion);
+        // STEP 11: Verification
+        await verifyUpdateDeployment(spinner, versionInfo.latestVersion);
+        // STEP 12: Cleanup backup
+        await cleanupBackup(backupDir, spinner);
+        backupDir = null; // Mark as cleaned up
+        errorHandler.clearCleanup(); // Clear cleanup since we did it manually
+        // SUCCESS: Display summary
+        displayUpdateSummary(stats, versionInfo.currentVersion, versionInfo.latestVersion);
+    }
+    catch (error) {
+        // ROLLBACK on failure
+        if (spinner) {
+            spinner.fail('Update failed');
+        }
+        console.log('');
+        console.log(chalk.red.bold('❌ Update failed - Rolling back changes...\n'));
+        if (backupDir) {
+            try {
+                await rollbackFromBackup(backupDir);
+            }
+            catch {
+                // Rollback error already logged in rollbackFromBackup
+            }
+        }
+        // Import error utilities
+        const { displayInfo, getErrorMessage } = await import('../../utils/errors.js');
+        displayInfo('Try running: trinity deploy --force for a clean reinstall');
+        // Re-throw as UpdateError if it's not already a Trinity error
+        if (error instanceof UpdateError) {
+            throw error;
+        }
+        throw new UpdateError(`Update failed: ${getErrorMessage(error)}`, {
+            originalError: error,
+            backupDir: backupDir || 'none',
+        });
+    }
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,14 @@
+/**
+ * Update Knowledge Base Module
+ * Handles updating SDK-managed knowledge base files
+ * @module cli/commands/update/knowledge-base
+ */
+import { Ora } from 'ora';
+import { UpdateStats } from './types.js';
+/**
+ * Update SDK-managed knowledge base files (preserves user content)
+ * @param spinner - ora spinner instance for status display
+ * @param stats - update statistics to track progress
+ */
+export declare function updateKnowledgeBase(spinner: Ora, stats: UpdateStats): Promise<void>;
+//# sourceMappingURL=knowledge-base.d.ts.map

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

@@ -0,0 +1,38 @@
+/**
+ * Update Knowledge Base Module
+ * Handles updating SDK-managed knowledge base files
+ * @module cli/commands/update/knowledge-base
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import { getSDKPath } from './utils.js';
+/** SDK-managed knowledge base files (not user content) */
+const SDK_MANAGED_KB_FILES = [
+    'Trinity.md.template',
+    'CODING-PRINCIPLES.md.template',
+    'TESTING-PRINCIPLES.md.template',
+    'AI-DEVELOPMENT-GUIDE.md.template',
+    'DOCUMENTATION-CRITERIA.md.template',
+];
+/**
+ * Update SDK-managed knowledge base files (preserves user content)
+ * @param spinner - ora spinner instance for status display
+ * @param stats - update statistics to track progress
+ */
+export async function updateKnowledgeBase(spinner, stats) {
+    spinner.start('Updating knowledge base...');
+    const sdkPath = await getSDKPath();
+    const kbTemplatePath = path.join(sdkPath, 'dist/templates/knowledge-base');
+    for (const templateFile of SDK_MANAGED_KB_FILES) {
+        const sourcePath = path.join(kbTemplatePath, templateFile);
+        if (await fs.pathExists(sourcePath)) {
+            // Remove .template extension for target
+            const targetFile = templateFile.replace('.template', '');
+            const targetPath = path.join('trinity/knowledge-base', targetFile);
+            await fs.copy(sourcePath, targetPath, { overwrite: true });
+            stats.knowledgeBaseUpdated++;
+        }
+    }
+    spinner.succeed(`Knowledge base updated (${stats.knowledgeBaseUpdated} files)`);
+}
+//# sourceMappingURL=knowledge-base.js.map

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

@@ -0,0 +1,13 @@
+/**
+ * Update Pre-flight Checks Module
+ * Validates project state before performing update
+ * @module cli/commands/update/pre-flight
+ */
+import { Ora } from 'ora';
+/**
+ * Run pre-flight checks to ensure Trinity Method is deployed
+ * @param spinner - ora spinner instance for status display
+ * @throws {UpdateError} If pre-flight checks fail
+ */
+export declare function runUpdatePreflightChecks(spinner: Ora): Promise<void>;
+//# sourceMappingURL=pre-flight.d.ts.map

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

@@ -0,0 +1,37 @@
+/**
+ * Update Pre-flight Checks Module
+ * Validates project state before performing update
+ * @module cli/commands/update/pre-flight
+ */
+import fs from 'fs-extra';
+import { UpdateError } from '../../utils/error-classes.js';
+/**
+ * Run pre-flight checks to ensure Trinity Method is deployed
+ * @param spinner - ora spinner instance for status display
+ * @throws {UpdateError} If pre-flight checks fail
+ */
+export async function runUpdatePreflightChecks(spinner) {
+    spinner.start('Running pre-flight checks...');
+    // Check trinity directory exists
+    const trinityExists = await fs.pathExists('trinity');
+    if (!trinityExists) {
+        spinner.fail('Trinity Method not deployed');
+        const { displayInfo } = await import('../../utils/errors.js');
+        displayInfo('Use: trinity deploy to install');
+        throw new UpdateError('Trinity Method not deployed in this project', {
+            reason: 'trinity_directory_missing',
+        });
+    }
+    // Check .claude directory exists
+    const claudeExists = await fs.pathExists('.claude');
+    if (!claudeExists) {
+        spinner.fail('.claude directory not found');
+        const { displayInfo } = await import('../../utils/errors.js');
+        displayInfo('Trinity deployment appears incomplete');
+        throw new UpdateError('.claude directory not found', {
+            reason: 'claude_directory_missing',
+        });
+    }
+    spinner.succeed('Pre-flight checks passed');
+}
+//# sourceMappingURL=pre-flight.js.map

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

@@ -0,0 +1,20 @@
+/**
+ * Update Summary Module
+ * Displays update completion summary
+ * @module cli/commands/update/summary
+ */
+import { UpdateStats } from './types.js';
+/**
+ * Display update summary with statistics
+ * @param stats - Update statistics
+ * @param oldVersion - Version before update
+ * @param newVersion - Version after update
+ */
+export declare function displayUpdateSummary(stats: UpdateStats, oldVersion: string, newVersion: string): void;
+/**
+ * Display dry-run preview of update changes
+ * @param oldVersion - Current version
+ * @param newVersion - Target version
+ */
+export declare function displayDryRunPreview(oldVersion: string, newVersion: string): void;
+//# sourceMappingURL=summary.d.ts.map

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

@@ -0,0 +1,47 @@
+/**
+ * Update Summary Module
+ * Displays update completion summary
+ * @module cli/commands/update/summary
+ */
+import chalk from 'chalk';
+/**
+ * Display update summary with statistics
+ * @param stats - Update statistics
+ * @param oldVersion - Version before update
+ * @param newVersion - Version after update
+ */
+export function displayUpdateSummary(stats, oldVersion, newVersion) {
+    console.log('');
+    console.log(chalk.green.bold('✅ Trinity Method updated successfully!\n'));
+    console.log(chalk.cyan('📊 Update Statistics:\n'));
+    console.log(chalk.white(`   Agents Updated: ${stats.agentsUpdated}`));
+    console.log(chalk.white(`   Commands Updated: ${stats.commandsUpdated}`));
+    console.log(chalk.white(`   Templates Updated: ${stats.templatesUpdated}`));
+    console.log(chalk.white(`   Knowledge Base Updated: ${stats.knowledgeBaseUpdated}`));
+    console.log(chalk.white(`   Total Files Updated: ${stats.agentsUpdated + stats.commandsUpdated + stats.templatesUpdated + stats.knowledgeBaseUpdated}`));
+    console.log('');
+    console.log(chalk.gray(`   Version: ${oldVersion} → ${newVersion}\n`));
+}
+/**
+ * Display dry-run preview of update changes
+ * @param oldVersion - Current version
+ * @param newVersion - Target version
+ */
+export function displayDryRunPreview(oldVersion, newVersion) {
+    console.log(chalk.yellow('🔍 DRY RUN - Preview of changes:\n'));
+    console.log(chalk.white('   Would update:'));
+    console.log(chalk.gray(`   • 18 agent files in .claude/agents/`));
+    console.log(chalk.gray(`   • 16 slash commands in .claude/commands/`));
+    console.log(chalk.gray(`   • 6 work order templates in trinity/templates/`));
+    console.log(chalk.gray(`   • Knowledge base files (Trinity.md, CODING-PRINCIPLES.md, etc.)`));
+    console.log(chalk.gray(`   • Version file: ${oldVersion} → ${newVersion}`));
+    console.log('');
+    console.log(chalk.white('   Would preserve:'));
+    console.log(chalk.gray(`   • trinity/knowledge-base/ARCHITECTURE.md`));
+    console.log(chalk.gray(`   • trinity/knowledge-base/To-do.md`));
+    console.log(chalk.gray(`   • trinity/knowledge-base/ISSUES.md`));
+    console.log(chalk.gray(`   • trinity/knowledge-base/Technical-Debt.md`));
+    console.log('');
+    console.log(chalk.blue('💡 Run without --dry-run to perform update\n'));
+}
+//# sourceMappingURL=summary.js.map

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

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

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

@@ -0,0 +1,25 @@
+/**
+ * Update Templates Module
+ * Handles updating work order template files
+ * @module cli/commands/update/templates
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import { getSDKPath } from './utils.js';
+/**
+ * Update work order templates from SDK to trinity/templates/
+ * @param spinner - ora spinner instance for status display
+ * @param stats - update statistics to track progress
+ */
+export async function updateTemplates(spinner, stats) {
+    spinner.start('Updating work order templates...');
+    const sdkPath = await getSDKPath();
+    const woTemplatePath = path.join(sdkPath, 'dist/templates/work-orders');
+    if (await fs.pathExists(woTemplatePath)) {
+        await fs.copy(woTemplatePath, 'trinity/templates', { overwrite: true });
+        const files = await fs.readdir(woTemplatePath);
+        stats.templatesUpdated = files.length;
+    }
+    spinner.succeed(`Work order templates updated (${stats.templatesUpdated} files)`);
+}
+//# sourceMappingURL=templates.js.map

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

@@ -0,0 +1,13 @@
+/**
+ * Update Command Types
+ * Shared type definitions for update command
+ * @module cli/commands/update/types
+ */
+export interface UpdateStats {
+    agentsUpdated: number;
+    templatesUpdated: number;
+    knowledgeBaseUpdated: number;
+    commandsUpdated: number;
+    filesUpdated: number;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,7 @@
+/**
+ * Update Command Types
+ * Shared type definitions for update command
+ * @module cli/commands/update/types
+ */
+export {};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,11 @@
+/**
+ * Update Utilities Module
+ * Shared utilities for update command
+ * @module cli/commands/update/utils
+ */
+/**
+ * Get SDK path for reading template files
+ * @returns Path to SDK directory
+ */
+export declare function getSDKPath(): Promise<string>;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1,19 @@
+/**
+ * Update Utilities Module
+ * Shared utilities for update command
+ * @module cli/commands/update/utils
+ */
+import fs from 'fs-extra';
+import path from 'path';
+/**
+ * Get SDK path for reading template files
+ * @returns Path to SDK directory
+ */
+export async function getSDKPath() {
+    // In tests it's process.cwd(), in production it's node_modules/@trinity-method/sdk
+    const sdkPath = (await fs.pathExists(path.join(process.cwd(), 'dist/templates')))
+        ? process.cwd() // Running from SDK root (tests or dev)
+        : path.join(process.cwd(), 'node_modules', '@trinity-method', 'sdk'); // Installed package
+    return sdkPath;
+}
+//# sourceMappingURL=utils.js.map

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

@@ -0,0 +1,20 @@
+/**
+ * Update Verification Module
+ * Verifies update deployment is successful
+ * @module cli/commands/update/verification
+ */
+import { Ora } from 'ora';
+/**
+ * Verify update deployment is successful
+ * @param spinner - ora spinner instance for status display
+ * @param expectedVersion - Expected version after update
+ * @throws {Error} If verification fails
+ */
+export declare function verifyUpdateDeployment(spinner: Ora, expectedVersion: string): Promise<void>;
+/**
+ * Update VERSION file with latest version
+ * @param spinner - ora spinner instance for status display
+ * @param version - Version string to write
+ */
+export declare function updateVersionFile(spinner: Ora, version: string): Promise<void>;
+//# sourceMappingURL=verification.d.ts.map

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

@@ -0,0 +1,54 @@
+/**
+ * Update Verification Module
+ * Verifies update deployment is successful
+ * @module cli/commands/update/verification
+ */
+import fs from 'fs-extra';
+import { validatePath } from '../../utils/validate-path.js';
+/** Verification checks to run after update */
+const VERIFICATION_CHECKS = [
+    { path: 'trinity/VERSION', desc: 'Version file' },
+    { path: '.claude/agents/leadership', desc: 'Leadership agents' },
+    { path: '.claude/agents/planning', desc: 'Planning agents' },
+    { path: '.claude/agents/aj-team', desc: 'AJ team agents' },
+    { path: '.claude/commands', desc: 'Slash commands' },
+    { path: 'trinity/templates', desc: 'Work order templates' },
+    { path: 'trinity/knowledge-base/Trinity.md', desc: 'Trinity knowledge base' },
+];
+/**
+ * Verify update deployment is successful
+ * @param spinner - ora spinner instance for status display
+ * @param expectedVersion - Expected version after update
+ * @throws {Error} If verification fails
+ */
+export async function verifyUpdateDeployment(spinner, expectedVersion) {
+    spinner.start('Verifying update...');
+    // Check all required paths exist
+    for (const check of VERIFICATION_CHECKS) {
+        if (!(await fs.pathExists(check.path))) {
+            spinner.fail(`Verification failed: ${check.desc} missing`);
+            throw new Error(`Update verification failed: ${check.path} not found`);
+        }
+    }
+    // Verify version was actually updated
+    const versionPath = 'trinity/VERSION';
+    const updatedVersion = (await fs.readFile(versionPath, 'utf8')).trim();
+    if (updatedVersion !== expectedVersion) {
+        spinner.fail('Version file not updated correctly');
+        throw new Error(`Version verification failed: expected ${expectedVersion}, got ${updatedVersion}`);
+    }
+    spinner.succeed('Verification passed');
+}
+/**
+ * Update VERSION file with latest version
+ * @param spinner - ora spinner instance for status display
+ * @param version - Version string to write
+ */
+export async function updateVersionFile(spinner, version) {
+    spinner.start('Updating version file...');
+    // Validate destination path for security
+    const destPath = validatePath('trinity/VERSION');
+    await fs.writeFile(destPath, version);
+    spinner.succeed('Version file updated');
+}
+//# sourceMappingURL=verification.js.map

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

@@ -0,0 +1,18 @@
+/**
+ * Update Version Detection Module
+ * Detects current and latest SDK versions
+ * @module cli/commands/update/version
+ */
+import { Ora } from 'ora';
+export interface VersionInfo {
+    currentVersion: string;
+    latestVersion: string;
+    isUpToDate: boolean;
+}
+/**
+ * Detect installed SDK version and compare with latest
+ * @param spinner - ora spinner instance for status display
+ * @returns Version information
+ */
+export declare function detectInstalledSDKVersion(spinner: Ora): Promise<VersionInfo>;
+//# sourceMappingURL=version.d.ts.map

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

@@ -0,0 +1,36 @@
+/**
+ * Update Version Detection Module
+ * Detects current and latest SDK versions
+ * @module cli/commands/update/version
+ */
+import fs from 'fs-extra';
+import chalk from 'chalk';
+import { getPackageJsonPath } from '../../utils/get-sdk-path.js';
+/**
+ * Detect installed SDK version and compare with latest
+ * @param spinner - ora spinner instance for status display
+ * @returns Version information
+ */
+export async function detectInstalledSDKVersion(spinner) {
+    spinner.start('Checking versions...');
+    // Read current version from trinity/VERSION
+    const versionPath = 'trinity/VERSION';
+    let currentVersion = '0.0.0';
+    if (await fs.pathExists(versionPath)) {
+        currentVersion = (await fs.readFile(versionPath, 'utf8')).trim();
+    }
+    // Read latest version from SDK package.json
+    const sdkPkgPath = await getPackageJsonPath();
+    const sdkPkg = JSON.parse(await fs.readFile(sdkPkgPath, 'utf8'));
+    const latestVersion = sdkPkg.version;
+    spinner.succeed('Version check complete');
+    console.log(chalk.gray(`   Current version: ${currentVersion}`));
+    console.log(chalk.gray(`   Latest version:  ${latestVersion}`));
+    console.log('');
+    return {
+        currentVersion,
+        latestVersion,
+        isUpToDate: currentVersion === latestVersion,
+    };
+}
+//# sourceMappingURL=version.js.map

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

@@ -0,0 +1,7 @@
+/**
+ * Update Command - Re-export from modular implementation
+ * @see src/cli/commands/update/ for modular implementation
+ * @module cli/commands/update
+ */
+export { update } from './update/index.js';
+//# sourceMappingURL=update.d.ts.map

package/dist/cli/commands/update.js

@@ -0,0 +1,7 @@
+/**
+ * Update Command - Re-export from modular implementation
+ * @see src/cli/commands/update/ for modular implementation
+ * @module cli/commands/update
+ */
+export { update } from './update/index.js';
+//# sourceMappingURL=update.js.map

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import { deploy } from './commands/deploy/index.js';
+import { update } from './commands/update.js';
+import { errorHandler } from './utils/error-handler.js';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const pkg = JSON.parse(readFileSync(join(__dirname, '../../package.json'), 'utf8'));
+program
+    .name('trinity')
+    .description('Trinity Method SDK - Investigation-first development with AI agents')
+    .version(`${pkg.version} (Trinity Method SDK)`, '-v, --version', 'Output the current version');
+// ========================================
+// Setup Commands
+// ========================================
+program
+    .command('deploy')
+    .description('Deploy Trinity Method to current project')
+    .option('--name <name>', 'Project name (auto-detected if not specified)')
+    .option('--yes', 'Skip confirmation prompts')
+    .option('--dry-run', 'Preview changes without writing files')
+    .option('--force', 'Overwrite existing Trinity deployment')
+    .option('--skip-audit', 'Skip codebase metrics collection (faster, uses placeholders)')
+    .option('--ci-deploy', 'Deploy CI/CD workflow templates for automated testing')
+    .action(errorHandler.wrap(deploy));
+program
+    .command('update')
+    .description('Update Trinity Method to latest version')
+    .option('--all', 'Update all registered Trinity projects')
+    .option('--dry-run', 'Preview changes without writing files')
+    .action(errorHandler.wrap(update));
+program.parse();
+//# sourceMappingURL=index.js.map

package/dist/cli/types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * CLI Command Option Types
+ */
+export interface DeployOptions {
+    name?: string;
+    yes?: boolean;
+    dryRun?: boolean;
+    force?: boolean;
+    skipAudit?: boolean;
+    ciDeploy?: boolean;
+    lintingTools?: LintingTool[];
+    lintingDependencies?: string[];
+    lintingScripts?: Record<string, string>;
+    postInstallInstructions?: PostInstallInstruction[];
+}
+export interface UpdateOptions {
+    all?: boolean;
+    dryRun?: boolean;
+}
+export interface LintingTool {
+    id: string;
+    name: string;
+    file: string;
+    description?: string;
+    template?: string;
+    framework?: string;
+    language?: string;
+    recommended?: boolean;
+    dependencies?: string[];
+    scripts?: Record<string, string>;
+    requiresTypeScript?: boolean;
+    postInstall?: string;
+}
+export interface PostInstallInstruction {
+    command: string;
+    description?: string;
+}
+export interface Stack {
+    framework: string;
+    language: string;
+    sourceDir: string;
+    sourceDirs: string[];
+    packageManager?: string;
+}
+export interface CodebaseMetrics {
+    todoCount: number;
+    todoComments: number;
+    fixmeComments: number;
+    hackComments: number;
+    consoleStatements: number;
+    commentedCodeBlocks: number;
+    totalFiles: number;
+    filesOver500: number;
+    filesOver1000: number;
+    filesOver3000: number;
+    avgFileLength: number;
+    largestFiles: Array<{
+        file: string;
+        lines: number;
+    }>;
+    dependencies: Record<string, string>;
+    dependencyCount: number;
+    devDependencies: Record<string, string>;
+    devDependencyCount: number;
+    commitCount: number;
+    contributors: number;
+    lastCommitDate: string;
+    frameworkVersion: string;
+    packageManager: string;
+}
+export interface DeploymentStats {
+    agents: number;
+    templates: number;
+    directories: number;
+    files: number;
+}
+//# sourceMappingURL=types.d.ts.map