trinity-method-sdk 2.0.9 → 2.2.0

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

@@ -13,67 +13,40 @@ const COMMAND_CATEGORIES = [
     'execution',
     'investigation',
     'infrastructure',
+    'maintenance',
     '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') ||
-        filename.includes('audit') ||
-        filename.includes('changelog') ||
-        filename.includes('docs') ||
-        filename.includes('readme')) {
-        return 'execution';
-    }
-    else if (filename.includes('investigation') || filename.includes('investigate')) {
-        return 'investigation';
-    }
-    else if (filename.includes('init')) {
-        return 'infrastructure';
-    }
-    return 'utility';
-}
 /**
  * Update slash command files from SDK to .claude/commands/
+ * Commands are now organized by category in source templates
  * @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');
+    const commandsTemplatePath = path.join(sdkPath, 'dist/templates/.claude/commands');
     if (!(await fs.pathExists(commandsTemplatePath))) {
         spinner.warn('Commands template path not found, skipping');
         return;
     }
-    // Create command category directories
+    // Iterate through each category directory
     for (const category of COMMAND_CATEGORIES) {
+        const sourceCategoryPath = path.join(commandsTemplatePath, category);
         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.template')) {
-            const sourcePath = path.join(commandsTemplatePath, file);
-            const category = determineCommandCategory(file);
-            // Remove .template extension for deployed file
-            const deployedFileName = file.replace('.template', '');
-            const targetPath = path.join('.claude/commands', category, deployedFileName);
-            await fs.copy(sourcePath, targetPath, { overwrite: true });
-            stats.commandsUpdated++;
+        if (await fs.pathExists(sourceCategoryPath)) {
+            await fs.ensureDir(targetCategoryPath);
+            const commandFiles = await fs.readdir(sourceCategoryPath);
+            for (const file of commandFiles) {
+                if (file.endsWith('.md.template')) {
+                    const sourcePath = path.join(sourceCategoryPath, file);
+                    // Remove .template extension for deployed file
+                    const deployedFileName = file.replace('.template', '');
+                    const targetPath = path.join(targetCategoryPath, deployedFileName);
+                    await fs.copy(sourcePath, targetPath, { overwrite: true });
+                    stats.commandsUpdated++;
+                }
+            }
         }
     }
     spinner.succeed(`Slash commands updated (${stats.commandsUpdated} files)`);

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

@@ -22,13 +22,13 @@ const SDK_MANAGED_KB_FILES = [
 export async function updateKnowledgeBase(spinner, stats) {
     spinner.start('Updating knowledge base...');
     const sdkPath = await getSDKPath();
-    const kbTemplatePath = path.join(sdkPath, 'dist/templates/knowledge-base');
+    const kbTemplatePath = path.join(sdkPath, 'dist/templates/trinity/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);
+            const targetPath = path.join('.claude/trinity/knowledge-base', targetFile);
             await fs.copy(sourcePath, targetPath, { overwrite: true });
             stats.knowledgeBaseUpdated++;
         }

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

@@ -12,26 +12,26 @@ import { UpdateError } from '../../utils/error-classes.js';
  */
 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');
+        displayInfo('Use: trinity deploy to install');
         throw new UpdateError('.claude directory not found', {
             reason: 'claude_directory_missing',
         });
     }
+    // Check .claude/trinity directory exists
+    const trinityExists = await fs.pathExists('.claude/trinity');
+    if (!trinityExists) {
+        spinner.fail('Trinity Method not deployed');
+        const { displayInfo } = await import('../../utils/errors.js');
+        displayInfo('Trinity deployment appears incomplete');
+        throw new UpdateError('Trinity Method not deployed in this project', {
+            reason: 'trinity_directory_missing',
+        });
+    }
     spinner.succeed('Pre-flight checks passed');
 }
 //# sourceMappingURL=pre-flight.js.map

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

@@ -32,15 +32,15 @@ export function displayDryRunPreview(oldVersion, newVersion) {
     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(`   • 6 work order templates in .claude/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(chalk.gray(`   • .claude/trinity/knowledge-base/ARCHITECTURE.md`));
+    console.log(chalk.gray(`   • .claude/trinity/knowledge-base/To-do.md`));
+    console.log(chalk.gray(`   • .claude/trinity/knowledge-base/ISSUES.md`));
+    console.log(chalk.gray(`   • .claude/trinity/knowledge-base/Technical-Debt.md`));
     console.log('');
     console.log(chalk.blue('💡 Run without --dry-run to perform update\n'));
 }

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

@@ -8,6 +8,38 @@ import path from 'path';
 import { getSDKPath } from './utils.js';
 /** Template directories to update */
 const TEMPLATE_DIRS = ['work-orders', 'documentation', 'investigations'];
+/**
+ * Recursively copy files from source to target directory
+ * @param sourcePath - source directory path
+ * @param targetPath - target directory path
+ * @param stats - update statistics to track progress
+ */
+async function copyTemplatesRecursively(sourcePath, targetPath, stats) {
+    const entries = await fs.readdir(sourcePath, { withFileTypes: true });
+    for (const entry of entries) {
+        const sourceFile = path.join(sourcePath, entry.name);
+        const targetFile = path.join(targetPath, entry.name);
+        if (entry.isDirectory()) {
+            // Recursively copy subdirectories
+            await fs.ensureDir(targetFile);
+            await copyTemplatesRecursively(sourceFile, targetFile, stats);
+        }
+        else if (entry.isFile()) {
+            // Copy template files (.md.template files get .template stripped)
+            if (entry.name.endsWith('.md.template')) {
+                const deployedFileName = entry.name.replace('.template', '');
+                const targetFilePath = path.join(targetPath, deployedFileName);
+                await fs.copy(sourceFile, targetFilePath, { overwrite: true });
+                stats.templatesUpdated++;
+            }
+            // Copy plain .md files (e.g., Mermaid diagram templates)
+            else if (entry.name.endsWith('.md')) {
+                await fs.copy(sourceFile, targetFile, { overwrite: true });
+                stats.templatesUpdated++;
+            }
+        }
+    }
+}
 /**
  * Update template files from SDK to trinity/templates/
  * @param spinner - ora spinner instance for status display
@@ -16,23 +48,13 @@ const TEMPLATE_DIRS = ['work-orders', 'documentation', 'investigations'];
 export async function updateTemplates(spinner, stats) {
     spinner.start('Updating templates...');
     const sdkPath = await getSDKPath();
-    const sdkTemplatesPath = path.join(sdkPath, 'dist/templates');
+    const sdkTemplatesPath = path.join(sdkPath, 'dist/templates/trinity/templates');
     for (const templateDir of TEMPLATE_DIRS) {
         const sourcePath = path.join(sdkTemplatesPath, templateDir);
-        const targetPath = path.join('trinity/templates', templateDir);
+        const targetPath = path.join('.claude/trinity/templates', templateDir);
         if (await fs.pathExists(sourcePath)) {
             await fs.ensureDir(targetPath);
-            const files = await fs.readdir(sourcePath);
-            // Copy each file individually, stripping .template extension
-            for (const file of files) {
-                if (file.endsWith('.md.template')) {
-                    const sourceFile = path.join(sourcePath, file);
-                    const deployedFileName = file.replace('.template', '');
-                    const targetFile = path.join(targetPath, deployedFileName);
-                    await fs.copy(sourceFile, targetFile, { overwrite: true });
-                    stats.templatesUpdated++;
-                }
-            }
+            await copyTemplatesRecursively(sourcePath, targetPath, stats);
         }
     }
     spinner.succeed(`Templates updated (${stats.templatesUpdated} files)`);

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

@@ -7,13 +7,13 @@ 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/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' },
+    { path: '.claude/trinity/templates', desc: 'Work order templates' },
+    { path: '.claude/trinity/knowledge-base/Trinity.md', desc: 'Trinity knowledge base' },
 ];
 /**
  * Verify update deployment is successful
@@ -31,7 +31,7 @@ export async function verifyUpdateDeployment(spinner, expectedVersion) {
         }
     }
     // Verify version was actually updated
-    const versionPath = 'trinity/VERSION';
+    const versionPath = '.claude/trinity/VERSION';
     const updatedVersion = (await fs.readFile(versionPath, 'utf8')).trim();
     if (updatedVersion !== expectedVersion) {
         spinner.fail('Version file not updated correctly');
@@ -47,7 +47,7 @@ export async function verifyUpdateDeployment(spinner, expectedVersion) {
 export async function updateVersionFile(spinner, version) {
     spinner.start('Updating version file...');
     // Validate destination path for security
-    const destPath = validatePath('trinity/VERSION');
+    const destPath = validatePath('.claude/trinity/VERSION');
     await fs.writeFile(destPath, version);
     spinner.succeed('Version file updated');
 }

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

@@ -14,7 +14,7 @@ import { getPackageJsonPath } from '../../utils/get-sdk-path.js';
 export async function detectInstalledSDKVersion(spinner) {
     spinner.start('Checking versions...');
     // Read current version from trinity/VERSION
-    const versionPath = 'trinity/VERSION';
+    const versionPath = '.claude/trinity/VERSION';
     let currentVersion = '0.0.0';
     if (await fs.pathExists(versionPath)) {
         currentVersion = (await fs.readFile(versionPath, 'utf8')).trim();

package/dist/cli/utils/deploy-ci.d.ts

@@ -12,11 +12,12 @@ interface CIDeployOptions {
     force?: boolean;
 }
 /**
- * Deploy CI/CD workflow templates based on detected Git platform
+ * Deploy CI workflow templates based on detected Git platform
  *
  * @param options - Deployment options
+ * @param variables - Template variables for processing
  * @returns Deployment results with statistics
  */
-export declare function deployCITemplates(options?: CIDeployOptions): Promise<CIDeploymentStats>;
+export declare function deployCITemplates(options?: CIDeployOptions, variables?: Record<string, string>): Promise<CIDeploymentStats>;
 export {};
 //# sourceMappingURL=deploy-ci.d.ts.map

package/dist/cli/utils/deploy-ci.js

@@ -3,6 +3,7 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import { validatePath } from './validate-path.js';
+import { processTemplate } from './template-processor.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 /**
@@ -20,7 +21,7 @@ async function deployGitLabCI(templatesPath, options, stats) {
         const content = await fs.readFile(gitlabTemplate, 'utf8');
         const gitlabCIExists = await fs.pathExists('.gitlab-ci.yml');
         if (gitlabCIExists && !options.force) {
-            stats.skipped.push('.gitlab-ci.yml (already exists)');
+            stats.skipped.push('.gitlab-ci.yml (already exists, use --force to overwrite)');
             return;
         }
         // Validate destination path for security
@@ -34,12 +35,13 @@ async function deployGitLabCI(templatesPath, options, stats) {
     }
 }
 /**
- * Deploy CI/CD workflow templates based on detected Git platform
+ * Deploy CI workflow templates based on detected Git platform
  *
  * @param options - Deployment options
+ * @param variables - Template variables for processing
  * @returns Deployment results with statistics
  */
-export async function deployCITemplates(options = {}) {
+export async function deployCITemplates(options = {}, variables = {}) {
     const stats = {
         deployed: [],
         skipped: [],
@@ -49,33 +51,31 @@ export async function deployCITemplates(options = {}) {
         // Detect Git platform
         const platform = await detectGitPlatform();
         const templatesPath = path.join(__dirname, '../../templates/ci');
-        // GitHub Actions - Deploy both CI and CD workflows
+        // GitHub Actions - Deploy CI workflow
         if (platform === 'github' || platform === 'unknown') {
             try {
                 await fs.ensureDir('.github/workflows');
                 // Deploy CI workflow
                 const ciTemplate = path.join(templatesPath, 'ci.yml.template');
                 if (await fs.pathExists(ciTemplate)) {
-                    const content = await fs.readFile(ciTemplate, 'utf8');
-                    // Validate destination path for security
-                    const destPath = validatePath('.github/workflows/ci.yml');
-                    await fs.writeFile(destPath, content);
-                    stats.deployed.push('.github/workflows/ci.yml');
-                }
-                // Deploy CD workflow
-                const cdTemplate = path.join(templatesPath, 'cd.yml.template');
-                if (await fs.pathExists(cdTemplate)) {
-                    const content = await fs.readFile(cdTemplate, 'utf8');
-                    // Validate destination path for security
-                    const destPath = validatePath('.github/workflows/cd.yml');
-                    await fs.writeFile(destPath, content);
-                    stats.deployed.push('.github/workflows/cd.yml');
+                    const ciExists = await fs.pathExists('.github/workflows/ci.yml');
+                    if (ciExists && !options.force) {
+                        stats.skipped.push('.github/workflows/ci.yml (already exists, use --force to overwrite)');
+                    }
+                    else {
+                        const content = await fs.readFile(ciTemplate, 'utf8');
+                        const processed = processTemplate(content, variables);
+                        // Validate destination path for security
+                        const destPath = validatePath('.github/workflows/ci.yml');
+                        await fs.writeFile(destPath, processed);
+                        stats.deployed.push('.github/workflows/ci.yml');
+                    }
                 }
             }
             catch (error) {
                 const { getErrorMessage } = await import('./errors.js');
                 stats.errors.push({
-                    file: '.github/workflows/ci.yml or cd.yml',
+                    file: '.github/workflows/ci.yml',
                     error: getErrorMessage(error),
                 });
             }
@@ -84,22 +84,22 @@ export async function deployCITemplates(options = {}) {
         if (platform === 'gitlab') {
             await deployGitLabCI(templatesPath, options, stats);
         }
-        // Generic template (always deploy to trinity/templates/ci)
+        // Generic template (always deploy to .claude/trinity/templates/ci)
         try {
-            await fs.ensureDir('trinity/templates/ci');
+            await fs.ensureDir('.claude/trinity/templates/ci');
             const genericTemplate = path.join(templatesPath, 'generic-ci.yml');
             if (await fs.pathExists(genericTemplate)) {
                 const content = await fs.readFile(genericTemplate, 'utf8');
                 // Validate destination path for security
-                const destPath = validatePath('trinity/templates/ci/generic-ci.yml');
+                const destPath = validatePath('.claude/trinity/templates/ci/generic-ci.yml');
                 await fs.writeFile(destPath, content);
-                stats.deployed.push('trinity/templates/ci/generic-ci.yml');
+                stats.deployed.push('.claude/trinity/templates/ci/generic-ci.yml');
             }
         }
         catch (error) {
             const { getErrorMessage } = await import('./errors.js');
             stats.errors.push({
-                file: 'trinity/templates/ci/generic-ci.yml',
+                file: '.claude/trinity/templates/ci/generic-ci.yml',
                 error: getErrorMessage(error),
             });
         }

package/dist/cli/utils/deploy-linting.js

@@ -1,10 +1,11 @@
 import fs from 'fs-extra';
 import path from 'path';
+import chalk from 'chalk';
 import { processTemplate } from './template-processor.js';
 import { validatePath } from './validate-path.js';
 export async function deployLintingTool(tool, stack, templatesPath, variables) {
     const frameworkDir = getFrameworkDirectory(stack.framework);
-    const templateDir = path.join(templatesPath, 'linting', frameworkDir);
+    const templateDir = path.join(templatesPath, 'root/linting', frameworkDir);
     switch (tool.id) {
         case 'eslint':
         case 'eslint-typescript': // Alias for eslint with TypeScript (backward compatibility)
@@ -14,7 +15,7 @@ export async function deployLintingTool(tool, stack, templatesPath, variables) {
             await deployPrettier(tool, templateDir, variables);
             break;
         case 'precommit':
-            await deployPreCommit(tool, templateDir, variables);
+            await deployPreCommit(tool, stack, templateDir, variables);
             break;
         case 'typescript-eslint':
             await deployTypeScriptESLint(tool, stack, templateDir, variables);
@@ -46,7 +47,22 @@ function getFrameworkDirectory(framework) {
     };
     return frameworkMap[framework] || 'nodejs';
 }
-async function deployESLint(tool, stack, templateDir, variables) {
+async function deployESLint(_tool, stack, templateDir, variables) {
+    // Skip if ESLint config already exists
+    const eslintConfigs = [
+        '.eslintrc.json',
+        '.eslintrc.js',
+        '.eslintrc.cjs',
+        '.eslintrc.yml',
+        'eslint.config.js',
+        'eslint.config.mjs',
+    ];
+    for (const config of eslintConfigs) {
+        if (await fs.pathExists(config)) {
+            console.warn(chalk.yellow(`   Skipped: .eslintrc.json (${config} already exists, use --force to overwrite)`));
+            return;
+        }
+    }
     let templateFile;
     if (stack.language === 'TypeScript') {
         templateFile = '.eslintrc-typescript.json.template';
@@ -64,7 +80,22 @@ async function deployESLint(tool, stack, templateDir, variables) {
     const destPath = validatePath('.eslintrc.json');
     await fs.writeFile(destPath, processed);
 }
-async function deployPrettier(tool, templateDir, variables) {
+async function deployPrettier(_tool, templateDir, variables) {
+    // Skip if Prettier config already exists
+    const prettierConfigs = [
+        '.prettierrc.json',
+        '.prettierrc',
+        '.prettierrc.js',
+        '.prettierrc.cjs',
+        '.prettierrc.yml',
+        'prettier.config.js',
+    ];
+    for (const config of prettierConfigs) {
+        if (await fs.pathExists(config)) {
+            console.warn(chalk.yellow(`   Skipped: .prettierrc.json (${config} already exists, use --force to overwrite)`));
+            return;
+        }
+    }
     const templatePath = path.join(templateDir, '.prettierrc.json.template');
     const content = await fs.readFile(templatePath, 'utf8');
     const processed = processTemplate(content, variables);
@@ -72,7 +103,71 @@ async function deployPrettier(tool, templateDir, variables) {
     const destPath = validatePath('.prettierrc.json');
     await fs.writeFile(destPath, processed);
 }
-async function deployPreCommit(tool, templateDir, variables) {
+async function deployPreCommit(tool, stack, templateDir, variables) {
+    // Skip if existing pre-commit setup detected
+    if (await hasExistingPreCommitSetup()) {
+        console.warn(chalk.yellow('   Existing pre-commit configuration detected, skipping deployment'));
+        return;
+    }
+    const framework = stack.framework;
+    if (framework === 'Node.js' || framework === 'React' || framework === 'Next.js') {
+        await deployHuskyPreCommit(tool, templateDir, variables);
+    }
+    else {
+        await deployPythonPreCommit(tool, templateDir, variables);
+    }
+}
+async function hasExistingPreCommitSetup() {
+    // Check for .husky/ directory
+    if (await fs.pathExists('.husky')) {
+        return true;
+    }
+    // Check for .pre-commit-config.yaml
+    if (await fs.pathExists('.pre-commit-config.yaml')) {
+        return true;
+    }
+    // Check package.json for husky or lint-staged
+    if (await fs.pathExists('package.json')) {
+        const pkg = await fs.readJson('package.json');
+        const allDeps = {
+            ...pkg.dependencies,
+            ...pkg.devDependencies,
+        };
+        if (allDeps.husky || allDeps['lint-staged']) {
+            return true;
+        }
+    }
+    return false;
+}
+async function deployHuskyPreCommit(_tool, templateDir, variables) {
+    // Create .husky directory
+    await fs.ensureDir('.husky');
+    // Deploy pre-commit hook from template
+    const templatePath = path.join(templateDir, '.husky-pre-commit.template');
+    const content = await fs.readFile(templatePath, 'utf8');
+    const processed = processTemplate(content, variables);
+    const destPath = validatePath('.husky/pre-commit');
+    await fs.writeFile(destPath, processed, { mode: 0o755 });
+    // Add lint-staged config to package.json
+    await addLintStagedConfig();
+}
+async function addLintStagedConfig() {
+    const packageJsonPath = 'package.json';
+    if (!(await fs.pathExists(packageJsonPath))) {
+        return;
+    }
+    const pkg = await fs.readJson(packageJsonPath);
+    if (pkg['lint-staged']) {
+        return; // Already has lint-staged config
+    }
+    pkg['lint-staged'] = {
+        '*.{ts,tsx}': ['eslint --fix', 'prettier --write'],
+        '*.{js,jsx}': ['eslint --fix', 'prettier --write'],
+        '*.{json,md,yml,yaml}': ['prettier --write'],
+    };
+    await fs.writeJson(packageJsonPath, pkg, { spaces: 2 });
+}
+async function deployPythonPreCommit(_tool, templateDir, variables) {
     const templatePath = path.join(templateDir, '.pre-commit-config.yaml.template');
     const content = await fs.readFile(templatePath, 'utf8');
     const processed = processTemplate(content, variables);
@@ -116,7 +211,7 @@ async function deployPythonTool(tool, templateDir, variables) {
         await fs.writeFile(destPath, processed);
     }
 }
-async function deployDartAnalyzer(tool, templateDir, variables) {
+async function deployDartAnalyzer(_tool, templateDir, variables) {
     const templatePath = path.join(templateDir, 'analysis_options.yaml.template');
     const content = await fs.readFile(templatePath, 'utf8');
     const processed = processTemplate(content, variables);

package/dist/cli/utils/error-classes.d.ts

@@ -10,7 +10,7 @@
 export declare class TrinityCLIError extends Error {
     readonly code: string;
     readonly exitCode: number;
-    readonly context?: Record<string, unknown>;
+    readonly context?: Record<string, unknown> | undefined;
     /**
      * Create a Trinity CLI error
      * @param message - Human-readable error message
@@ -18,7 +18,7 @@ export declare class TrinityCLIError extends Error {
      * @param exitCode - Process exit code (default: 1)
      * @param context - Additional context for debugging
      */
-    constructor(message: string, code: string, exitCode?: number, context?: Record<string, unknown>);
+    constructor(message: string, code: string, exitCode?: number, context?: Record<string, unknown> | undefined);
     /**
      * Format error for user display
      * @returns Formatted error message with code

package/dist/cli/utils/linting-tools.js

@@ -27,10 +27,14 @@ export const lintingTools = {
         {
             id: 'precommit',
             name: 'Pre-commit hooks',
-            description: 'Git hooks for code quality',
-            file: '.pre-commit-config.yaml',
+            description: 'Git hooks for code quality (husky + lint-staged)',
+            file: '.husky/pre-commit',
             recommended: true,
-            dependencies: [],
+            dependencies: ['husky@^9.1.7', 'lint-staged@^16.2.0'],
+            scripts: {
+                prepare: 'husky',
+            },
+            postInstall: 'npm install',
         },
         {
             id: 'typescript-eslint',
@@ -69,10 +73,14 @@ export const lintingTools = {
         {
             id: 'precommit',
             name: 'Pre-commit hooks',
-            description: 'Git hooks for code quality',
-            file: '.pre-commit-config.yaml',
+            description: 'Git hooks for code quality (husky + lint-staged)',
+            file: '.husky/pre-commit',
             recommended: true,
-            dependencies: [],
+            dependencies: ['husky@^9.1.7', 'lint-staged@^16.2.0'],
+            scripts: {
+                prepare: 'husky',
+            },
+            postInstall: 'npm install',
         },
         {
             id: 'typescript-eslint',

package/dist/cli/utils/template-processor.js

@@ -24,14 +24,12 @@ const VARIABLE_RESOLVERS = {
     DEPLOYMENT_TIMESTAMP: (v) => toString(v.DEPLOYMENT_TIMESTAMP || v.timestamp) || new Date().toISOString(),
     LANGUAGE: (v) => toString(v.LANGUAGE || v.language) || 'Unknown',
     PACKAGE_MANAGER: (v) => toString(v.PACKAGE_MANAGER || v.packageManager) || 'npm',
-    TRINITY_VERSION: (v) => toString(v.TRINITY_VERSION) || '2.0.9',
+    TRINITY_VERSION: (v) => toString(v.TRINITY_VERSION) || '2.1.0',
     TECHNOLOGY_STACK: (v) => toString(v.TECHNOLOGY_STACK || v.TECH_STACK || v.techStack) || 'Unknown',
     PRIMARY_FRAMEWORK: (v) => toString(v.PRIMARY_FRAMEWORK || v.FRAMEWORK || v.framework) || 'Generic',
     CURRENT_DATE: (v) => toString(v.CURRENT_DATE) || new Date().toISOString().split('T')[0],
     PROJECT_VAR_NAME: (v) => resolveProjectVarName(v),
-    TRINITY_HOME: (v) => toString(v.TRINITY_HOME) ||
-        process.env.TRINITY_HOME ||
-        'C:/Users/lukaf/Desktop/Dev Work/trinity-method',
+    TRINITY_HOME: (v) => toString(v.TRINITY_HOME) || process.env.TRINITY_HOME || process.cwd(),
 };
 export function processTemplate(content, variables) {
     let processed = content;