trinity-method-sdk 2.0.0

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

@@ -0,0 +1,14 @@
+/**
+ * Agent configuration deployment
+ */
+import type { Spinner } from './types.js';
+/**
+ * Deploy Claude Code agent configurations
+ *
+ * @param templatesPath - Path to templates directory
+ * @param variables - Template variables for substitution
+ * @param spinner - Spinner instance for status updates
+ * @returns Number of agents deployed
+ */
+export declare function deployAgents(templatesPath: string, variables: Record<string, string>, spinner: Spinner): Promise<number>;
+//# sourceMappingURL=agents.d.ts.map

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

@@ -0,0 +1,59 @@
+/**
+ * Agent configuration 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 Claude Code agent configurations
+ *
+ * @param templatesPath - Path to templates directory
+ * @param variables - Template variables for substitution
+ * @param spinner - Spinner instance for status updates
+ * @returns Number of agents deployed
+ */
+export async function deployAgents(templatesPath, variables, spinner) {
+    spinner.start('Deploying Claude Code agents...');
+    let agentsDeployed = 0;
+    const agentDirs = [
+        { dir: 'leadership', agents: ['aly-cto.md', 'aj-maestro.md'] },
+        {
+            dir: 'deployment',
+            agents: ['tan-structure.md', 'zen-knowledge.md', 'ino-context.md', 'ein-cicd.md'],
+        },
+        { dir: 'audit', agents: ['juno-auditor.md'] },
+        {
+            dir: 'planning',
+            agents: ['mon-requirements.md', 'ror-design.md', 'tra-planner.md', 'eus-decomposer.md'],
+        },
+        {
+            dir: 'aj-team',
+            agents: [
+                'kil-task-executor.md',
+                'bas-quality-gate.md',
+                'dra-code-reviewer.md',
+                'apo-documentation-specialist.md',
+                'bon-dependency-manager.md',
+                'cap-configuration-specialist.md',
+                'uro-refactoring-specialist.md',
+            ],
+        },
+    ];
+    for (const { dir, agents } of agentDirs) {
+        for (const agent of agents) {
+            const templatePath = path.join(templatesPath, 'agents', dir, `${agent}.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(`.claude/agents/${dir}/${agent}`);
+                await fs.writeFile(destPath, processed);
+                agentsDeployed++;
+            }
+        }
+    }
+    spinner.succeed(`Agents deployed (${agentsDeployed} agents)`);
+    return agentsDeployed;
+}
+//# sourceMappingURL=agents.js.map

package/dist/cli/commands/deploy/ci-cd.d.ts

@@ -0,0 +1,13 @@
+/**
+ * CI/CD workflow deployment
+ */
+import type { DeployOptions, Spinner } from './types.js';
+/**
+ * Deploy CI/CD workflow templates
+ *
+ * @param options - Deploy command options
+ * @param spinner - Spinner instance for status updates
+ * @returns Number of files deployed
+ */
+export declare function deployCICD(options: DeployOptions, spinner: Spinner): Promise<number>;
+//# sourceMappingURL=ci-cd.d.ts.map

package/dist/cli/commands/deploy/ci-cd.js

@@ -0,0 +1,50 @@
+/**
+ * CI/CD workflow deployment
+ */
+import chalk from 'chalk';
+import { deployCITemplates } from '../../utils/deploy-ci.js';
+/**
+ * Deploy CI/CD workflow templates
+ *
+ * @param options - Deploy command options
+ * @param spinner - Spinner instance for status updates
+ * @returns Number of files deployed
+ */
+export async function deployCICD(options, spinner) {
+    if (!options.ciDeploy) {
+        return 0;
+    }
+    spinner.start('Deploying CI/CD workflow templates...');
+    try {
+        const ciStats = await deployCITemplates(options);
+        if (ciStats.deployed.length > 0) {
+            spinner.succeed(`CI/CD templates deployed (${ciStats.deployed.length} files)`);
+            ciStats.deployed.forEach((file) => {
+                console.log(chalk.white(`   ✓ ${file}`));
+            });
+        }
+        else {
+            spinner.info('No CI/CD templates deployed');
+        }
+        if (ciStats.skipped.length > 0) {
+            console.log(chalk.yellow('   Skipped:'));
+            ciStats.skipped.forEach((file) => {
+                console.log(chalk.yellow(`   - ${file}`));
+            });
+        }
+        if (ciStats.errors.length > 0) {
+            spinner.warn('Some CI/CD templates failed to deploy');
+            ciStats.errors.forEach((err) => {
+                console.log(chalk.red(`   ✗ ${err.file || 'Error'}: ${err.error}`));
+            });
+        }
+        return ciStats.deployed.length;
+    }
+    catch (error) {
+        spinner.fail('CI/CD template deployment failed');
+        const { displayWarning, getErrorMessage } = await import('../../utils/errors.js');
+        displayWarning(getErrorMessage(error));
+        return 0;
+    }
+}
+//# sourceMappingURL=ci-cd.js.map

package/dist/cli/commands/deploy/claude-setup.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Claude Code setup (settings, employee directory, commands)
+ */
+import type { Spinner } from './types.js';
+/**
+ * Deploy Claude Code configuration files
+ *
+ * @param templatesPath - Path to templates directory
+ * @param variables - Template variables for substitution
+ * @param spinner - Spinner instance for status updates
+ * @returns Object with filesDeployed and commandsDeployed counts
+ */
+export declare function deployClaudeSetup(templatesPath: string, variables: Record<string, string>, spinner: Spinner): Promise<{
+    filesDeployed: number;
+    commandsDeployed: number;
+}>;
+//# sourceMappingURL=claude-setup.d.ts.map

package/dist/cli/commands/deploy/claude-setup.js

@@ -0,0 +1,91 @@
+/**
+ * Claude Code setup (settings, employee directory, commands)
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import { processTemplate } from '../../utils/template-processor.js';
+import { validatePath } from '../../utils/validate-path.js';
+/**
+ * Deploy Claude Code configuration files
+ *
+ * @param templatesPath - Path to templates directory
+ * @param variables - Template variables for substitution
+ * @param spinner - Spinner instance for status updates
+ * @returns Object with filesDeployed and commandsDeployed counts
+ */
+export async function deployClaudeSetup(templatesPath, variables, spinner) {
+    let filesDeployed = 0;
+    let commandsDeployed = 0;
+    // Deploy settings.json (empty - users can configure manually)
+    spinner.start('Creating Claude Code settings...');
+    const settingsPath = '.claude/settings.json';
+    if (!(await fs.pathExists(settingsPath))) {
+        await fs.writeJson(settingsPath, {}, { spaces: 2 });
+        filesDeployed++;
+    }
+    spinner.succeed('Claude Code settings created (empty - customize as needed)');
+    // Deploy Employee Directory
+    spinner.start('Deploying Employee Directory...');
+    const employeeDirectoryTemplate = path.join(templatesPath, 'claude', 'EMPLOYEE-DIRECTORY.md.template');
+    if (await fs.pathExists(employeeDirectoryTemplate)) {
+        const content = await fs.readFile(employeeDirectoryTemplate, 'utf8');
+        const processed = processTemplate(content, variables);
+        // Validate destination path for security
+        const destPath = validatePath('.claude/EMPLOYEE-DIRECTORY.md');
+        await fs.writeFile(destPath, processed);
+        filesDeployed++;
+        spinner.succeed('Employee Directory deployed');
+    }
+    else {
+        spinner.warn('Employee Directory template not found');
+    }
+    // Deploy slash commands (categorized)
+    spinner.start('Deploying Trinity slash commands...');
+    const commandsDir = '.claude/commands';
+    // Create categorized subdirectories
+    await fs.ensureDir(`${commandsDir}/session`);
+    await fs.ensureDir(`${commandsDir}/planning`);
+    await fs.ensureDir(`${commandsDir}/execution`);
+    await fs.ensureDir(`${commandsDir}/investigation`);
+    await fs.ensureDir(`${commandsDir}/infrastructure`);
+    await fs.ensureDir(`${commandsDir}/utility`);
+    // Command categorization map
+    const commandCategories = {
+        'trinity-start.md.template': 'session',
+        'trinity-continue.md.template': 'session',
+        'trinity-end.md.template': 'session',
+        'trinity-requirements.md.template': 'planning',
+        'trinity-design.md.template': 'planning',
+        'trinity-decompose.md.template': 'planning',
+        'trinity-plan.md.template': 'planning',
+        'trinity-orchestrate.md.template': 'execution',
+        'trinity-audit.md.template': 'execution',
+        'trinity-readme.md.template': 'execution',
+        'trinity-docs.md.template': 'execution',
+        'trinity-changelog.md.template': 'execution',
+        'trinity-create-investigation.md.template': 'investigation',
+        'trinity-plan-investigation.md.template': 'investigation',
+        'trinity-investigate-templates.md.template': 'investigation',
+        'trinity-init.md.template': 'infrastructure',
+        'trinity-agents.md.template': 'utility',
+        'trinity-verify.md.template': 'utility',
+        'trinity-workorder.md.template': 'utility',
+    };
+    const commandsTemplatePath = path.join(templatesPath, 'shared/claude-commands');
+    const commandFiles = await fs.readdir(commandsTemplatePath);
+    for (const file of commandFiles) {
+        if (file.endsWith('.md.template') && commandCategories[file]) {
+            const sourcePath = path.join(commandsTemplatePath, file);
+            const category = commandCategories[file];
+            // Remove .template extension for deployed files
+            const deployedName = file.replace('.template', '');
+            const destPath = path.join(commandsDir, category, deployedName);
+            await fs.copy(sourcePath, destPath);
+            commandsDeployed++;
+            filesDeployed++;
+        }
+    }
+    spinner.succeed(`Deployed ${commandsDeployed} Trinity slash commands (6 categories)`);
+    return { filesDeployed, commandsDeployed };
+}
+//# sourceMappingURL=claude-setup.js.map

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

@@ -0,0 +1,13 @@
+/**
+ * Interactive configuration for Trinity deployment
+ */
+import type { DeployOptions, DeployConfig, Stack } from './types.js';
+/**
+ * Prompt user for deployment configuration
+ *
+ * @param options - Deploy command options
+ * @param stack - Detected technology stack
+ * @returns Deployment configuration
+ */
+export declare function promptConfiguration(options: DeployOptions, stack: Stack): Promise<Partial<DeployConfig>>;
+//# sourceMappingURL=configuration.d.ts.map

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

@@ -0,0 +1,215 @@
+/**
+ * Interactive configuration for Trinity deployment
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { getRecommendedTools, getDependenciesForTools, getScriptsForTools, getPostInstallInstructions, } from '../../utils/linting-tools.js';
+/**
+ * Get default configuration for --yes flag
+ */
+function getDefaultConfig(options) {
+    return {
+        projectName: options.name || path.basename(process.cwd()),
+        enableLinting: false,
+        enableCICD: false,
+        lintingTools: [],
+        lintingDependencies: [],
+        lintingScripts: {},
+        postInstallInstructions: [],
+    };
+}
+/**
+ * Prompt for project name
+ */
+async function promptProjectName(defaultName) {
+    const nameAnswer = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'projectName',
+            message: 'Project name:',
+            default: defaultName,
+        },
+    ]);
+    return nameAnswer.projectName;
+}
+/**
+ * Display linting configuration summary
+ */
+function displayLintingConfig(tools, dependencies, scripts) {
+    console.log(chalk.cyan('\n📦 Will configure:'));
+    tools.forEach((tool) => {
+        console.log(chalk.white(`  ✓ ${tool.name} (${tool.file})`));
+        if (tool.description) {
+            console.log(chalk.gray(`    ${tool.description}`));
+        }
+    });
+    if (dependencies.length > 0) {
+        console.log(chalk.white('\n  Dependencies to add (run npm install after deployment):'));
+        dependencies.forEach((dep) => console.log(chalk.white(`    - ${dep}`)));
+    }
+    if (Object.keys(scripts).length > 0) {
+        console.log(chalk.white('\n  Scripts to add to package.json:'));
+        Object.entries(scripts).forEach(([name, _cmd]) => {
+            console.log(chalk.white(`    - npm run ${name}`));
+        });
+    }
+}
+/**
+ * Prompt for linting setup choice
+ */
+async function promptLintingChoice(stack) {
+    console.log(chalk.cyan('\n📋 Optional: Code Quality Tools\n'));
+    console.log(chalk.white(`Trinity can setup linting and formatting tools for ${stack.framework} projects.\n`));
+    const lintingChoice = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'setupLinting',
+            message: 'Setup linting configuration? (y/n)',
+            default: true,
+        },
+    ]);
+    if (lintingChoice.setupLinting) {
+        return 'recommended';
+    }
+    else {
+        return 'skip';
+    }
+}
+/**
+ * Configure recommended linting tools
+ */
+async function configureRecommendedLinting(stack) {
+    const tools = getRecommendedTools(stack.framework, stack.language);
+    console.log(chalk.green('\n✔ Setup linting configuration?'), 'Recommended\n');
+    const dependencies = getDependenciesForTools(tools);
+    const scripts = getScriptsForTools(tools);
+    displayLintingConfig(tools, dependencies, scripts);
+    return { tools, dependencies, scripts };
+}
+/**
+ * Detect Git platform from .git/config
+ */
+async function detectGitPlatform() {
+    try {
+        const gitConfigPath = '.git/config';
+        if (await fs.pathExists(gitConfigPath)) {
+            const gitConfig = await fs.readFile(gitConfigPath, 'utf8');
+            if (gitConfig.includes('github.com'))
+                return 'GitHub Actions';
+            if (gitConfig.includes('gitlab.com') || gitConfig.includes('gitlab'))
+                return 'GitLab CI';
+        }
+    }
+    catch {
+        // Ignore detection errors
+    }
+    return 'unknown';
+}
+/**
+ * Display CI/CD configuration summary
+ */
+function displayCICDConfig(platform) {
+    console.log(chalk.green('\n✔ Deploy CI/CD workflow templates?'), 'Yes');
+    if (platform !== 'unknown') {
+        console.log(chalk.cyan(`📦 Detected platform: ${platform}\n`));
+        console.log(chalk.white('  Will configure:'));
+        if (platform === 'GitHub Actions') {
+            console.log(chalk.white('  ✓ .github/workflows/trinity-ci.yml'));
+        }
+        else if (platform === 'GitLab CI') {
+            console.log(chalk.white('  ✓ .gitlab-ci.yml'));
+        }
+        console.log(chalk.white('  ✓ trinity/templates/ci/generic-ci.yml (reference)'));
+    }
+    else {
+        console.log(chalk.cyan('\n📦 Will configure:\n'));
+        console.log(chalk.white('  ✓ .github/workflows/trinity-ci.yml (GitHub Actions)'));
+        console.log(chalk.white('  ✓ trinity/templates/ci/generic-ci.yml (reference)'));
+    }
+}
+/**
+ * Prompt for CI/CD setup
+ */
+async function promptCICDSetup() {
+    console.log(chalk.cyan('\n⚙️  Optional: CI/CD Automation\n'));
+    console.log(chalk.white('Trinity can setup automated testing workflows for your CI/CD platform.\n'));
+    const ciChoice = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'setupCI',
+            message: 'Deploy CI/CD workflow templates?',
+            default: true,
+        },
+    ]);
+    if (ciChoice.setupCI) {
+        const platform = await detectGitPlatform();
+        displayCICDConfig(platform);
+        return true;
+    }
+    else {
+        console.log(chalk.gray('\n✔ Deploy CI/CD workflow templates?'), 'Skip\n');
+        return false;
+    }
+}
+/**
+ * Confirm deployment
+ */
+async function confirmDeployment() {
+    const confirmAnswer = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirmDeploy',
+            message: 'Proceed with deployment?',
+            default: true,
+        },
+    ]);
+    if (!confirmAnswer.confirmDeploy) {
+        console.log(chalk.yellow('\n🔸 Deployment cancelled\n'));
+        throw new Error('Deployment cancelled by user');
+    }
+}
+/**
+ * Prompt user for deployment configuration
+ *
+ * @param options - Deploy command options
+ * @param stack - Detected technology stack
+ * @returns Deployment configuration
+ */
+export async function promptConfiguration(options, stack) {
+    if (options.yes) {
+        return getDefaultConfig(options);
+    }
+    const projectName = await promptProjectName(options.name || path.basename(process.cwd()));
+    const lintingChoice = await promptLintingChoice(stack);
+    let selectedLintingTools = [];
+    let lintingDependencies = [];
+    let lintingScripts = {};
+    let enableLinting = false;
+    if (lintingChoice === 'recommended') {
+        enableLinting = true;
+        const config = await configureRecommendedLinting(stack);
+        selectedLintingTools = config.tools;
+        lintingDependencies = config.dependencies;
+        lintingScripts = config.scripts;
+    }
+    else {
+        console.log(chalk.gray('\n✔ Setup linting configuration?'), 'Skip\n');
+    }
+    const postInstallInstructions = selectedLintingTools.length > 0
+        ? getPostInstallInstructions(selectedLintingTools, stack.framework)
+        : [];
+    const enableCICD = await promptCICDSetup();
+    await confirmDeployment();
+    return {
+        projectName,
+        enableLinting,
+        enableCICD,
+        lintingTools: selectedLintingTools,
+        lintingDependencies,
+        lintingScripts,
+        postInstallInstructions,
+    };
+}
+//# sourceMappingURL=configuration.js.map

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

@@ -0,0 +1,12 @@
+/**
+ * Trinity directory structure creation
+ */
+import type { Spinner } from './types.js';
+/**
+ * Create complete Trinity directory structure
+ *
+ * @param spinner - Spinner instance for status updates
+ * @returns Number of directories created
+ */
+export declare function createDirectories(spinner: Spinner): Promise<number>;
+//# sourceMappingURL=directories.d.ts.map

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

@@ -0,0 +1,38 @@
+/**
+ * Trinity directory structure creation
+ */
+import fs from 'fs-extra';
+/**
+ * Create complete Trinity directory structure
+ *
+ * @param spinner - Spinner instance for status updates
+ * @returns Number of directories created
+ */
+export async function createDirectories(spinner) {
+    spinner.start('Creating Trinity Method structure...');
+    let directoriesCreated = 0;
+    // Trinity core directories
+    await fs.ensureDir('trinity/knowledge-base');
+    await fs.ensureDir('trinity/sessions');
+    await fs.ensureDir('trinity/investigations');
+    await fs.ensureDir('trinity/patterns');
+    await fs.ensureDir('trinity/work-orders');
+    await fs.ensureDir('trinity/templates');
+    await fs.ensureDir('trinity/reports');
+    await fs.ensureDir('trinity/investigations/plans');
+    await fs.ensureDir('trinity/archive/work-orders');
+    await fs.ensureDir('trinity/archive/investigations');
+    await fs.ensureDir('trinity/archive/reports');
+    await fs.ensureDir('trinity/archive/sessions');
+    directoriesCreated += 12;
+    // Claude Code directories
+    await fs.ensureDir('.claude/agents/leadership');
+    await fs.ensureDir('.claude/agents/deployment');
+    await fs.ensureDir('.claude/agents/audit');
+    await fs.ensureDir('.claude/agents/planning');
+    await fs.ensureDir('.claude/agents/aj-team');
+    directoriesCreated += 5;
+    spinner.succeed('Trinity Method structure created');
+    return directoriesCreated;
+}
+//# sourceMappingURL=directories.js.map

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

@@ -0,0 +1,12 @@
+/**
+ * .gitignore update for Trinity exclusions
+ */
+import type { Spinner } from './types.js';
+/**
+ * Update .gitignore to exclude Trinity files
+ *
+ * @param spinner - Spinner instance for status updates
+ * @returns True if .gitignore was updated, false otherwise
+ */
+export declare function updateGitignore(spinner: Spinner): Promise<boolean>;
+//# sourceMappingURL=gitignore.d.ts.map

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

@@ -0,0 +1,53 @@
+/**
+ * .gitignore update for Trinity exclusions
+ */
+import fs from 'fs-extra';
+import { validatePath } from '../../utils/validate-path.js';
+/**
+ * Update .gitignore to exclude Trinity files
+ *
+ * @param spinner - Spinner instance for status updates
+ * @returns True if .gitignore was updated, false otherwise
+ */
+export async function updateGitignore(spinner) {
+    spinner.start('Updating .gitignore...');
+    try {
+        const gitignorePath = '.gitignore';
+        let gitignoreContent = '';
+        // Read existing .gitignore if it exists
+        if (await fs.pathExists(gitignorePath)) {
+            gitignoreContent = await fs.readFile(gitignorePath, 'utf8');
+        }
+        // Trinity files to ignore
+        const trinityIgnores = [
+            '',
+            '# Trinity Method SDK',
+            'node_modules/',
+            '.claude/',
+            'trinity/',
+            '*CLAUDE.md',
+            'TRINITY.md',
+        ];
+        // Check if Trinity section already exists
+        if (!gitignoreContent.includes('# Trinity Method SDK')) {
+            // Append Trinity ignores
+            const newContent = `${gitignoreContent.trim()}\n${trinityIgnores.join('\n')}\n`;
+            // Validate destination path for security
+            const validatedPath = validatePath(gitignorePath);
+            await fs.writeFile(validatedPath, newContent);
+            spinner.succeed('.gitignore updated with Trinity exclusions');
+            return true;
+        }
+        else {
+            spinner.info('.gitignore already contains Trinity exclusions');
+            return false;
+        }
+    }
+    catch (error) {
+        spinner.warn('.gitignore update failed');
+        const { displayWarning, getErrorMessage } = await import('../../utils/errors.js');
+        displayWarning(getErrorMessage(error));
+        return false;
+    }
+}
+//# sourceMappingURL=gitignore.js.map

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

@@ -0,0 +1,38 @@
+/**
+ * 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 type { DeployOptions } from './types.js';
+/**
+ * Deploy Trinity Method SDK to project
+ * @param options - Deployment options
+ */
+export declare function deploy(options: DeployOptions): Promise<void>;
+//# sourceMappingURL=index.d.ts.map