trinity-method-sdk 2.2.0 → 2.2.1

package/CHANGELOG.md

@@ -7,6 +7,32 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.2.1] - 2026-02-24
+
+### Added
+
+- **Legacy deployment migration in update command** - `trinity update` now detects pre-2.2.0
+  `trinity/` deployments at project root and automatically migrates them to `.claude/trinity/`
+  (Issue #14)
+  - New `migration.ts` module with `detectLegacyDeployment()`, `migrateLegacyDeployment()`,
+    and `updateGitignoreForMigration()`
+  - Pre-flight checks updated to recognize legacy layouts instead of failing
+  - Version detection falls back to `trinity/VERSION` for legacy deployments
+  - User knowledge base files preserved during migration
+- **Gitignore migration in update command** - `trinity update` now updates `.gitignore`
+  patterns on every run, replacing old `trinity/` entries with current `.claude/trinity/`
+  patterns (Issue #14)
+
+### Fixed
+
+- **Restored `*CLAUDE.md` to deploy gitignore patterns** - `trinity deploy` now adds
+  `*CLAUDE.md` back to `.gitignore`, preventing project-specific CLAUDE.md files from being
+  committed to version control (Issue #14)
+- **depcheck false positive for `markdownlint-cli`** - Added `markdownlint-cli` to depcheck
+  ignores in CI workflow since it is used by npm scripts, not imported in code
+- **Integration test timeout on Windows CI** - Bumped integration test timeout from 60s to
+  120s in `jest.config.js` for slow Windows runners
+
 ## [2.2.0] - 2026-02-24
 
 ### Added

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

@@ -24,6 +24,7 @@ export async function updateGitignore(spinner) {
             '# Trinity Method SDK',
             '.claude/trinity/archive/',
             '.claude/trinity/templates/',
+            '*CLAUDE.md',
         ];
         // Check if Trinity section already exists
         if (!gitignoreContent.includes('# Trinity Method SDK')) {

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

@@ -10,6 +10,7 @@ import chalk from 'chalk';
 import inquirer from 'inquirer';
 import { runUpdatePreflightChecks } from './pre-flight.js';
 import { detectInstalledSDKVersion } from './version.js';
+import { detectLegacyDeployment, migrateLegacyDeployment, updateGitignoreForMigration, } from './migration.js';
 import { createUpdateBackup, restoreUserContent, rollbackFromBackup, cleanupBackup, } from './backup.js';
 import { updateAgents } from './agents.js';
 import { updateCommands } from './commands.js';
@@ -34,10 +35,23 @@ export async function update(options) {
         knowledgeBaseUpdated: 0,
         commandsUpdated: 0,
         filesUpdated: 0,
+        legacyMigrated: false,
+        gitignoreUpdated: false,
     };
     try {
         // STEP 1: Pre-flight checks
-        await runUpdatePreflightChecks(spinner);
+        const preflight = await runUpdatePreflightChecks(spinner);
+        // STEP 1.5: Legacy migration (pre-2.2.0 trinity/ → .claude/trinity/)
+        if (preflight.needsLegacyMigration) {
+            const legacyInfo = await detectLegacyDeployment(spinner);
+            if (legacyInfo.isLegacy) {
+                await migrateLegacyDeployment(spinner);
+                stats.legacyMigrated = true;
+            }
+        }
+        // STEP 1.7: Update .gitignore patterns
+        const gitignoreChanged = await updateGitignoreForMigration(spinner);
+        stats.gitignoreUpdated = gitignoreChanged;
         // STEP 2: Version check
         const versionInfo = await detectInstalledSDKVersion(spinner);
         if (versionInfo.isUpToDate && !options.force) {

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

@@ -0,0 +1,31 @@
+/**
+ * Update Migration Module
+ * Handles legacy deployment detection and migration from pre-2.2.0 structure
+ * @module cli/commands/update/migration
+ */
+import { Ora } from 'ora';
+export interface LegacyInfo {
+    isLegacy: boolean;
+    legacyVersion: string | null;
+}
+/**
+ * Detect if the project has a legacy (pre-2.2.0) Trinity deployment
+ * Legacy deployments use `trinity/` at root instead of `.claude/trinity/`
+ * @param spinner - ora spinner instance for status display
+ * @returns Legacy deployment info
+ */
+export declare function detectLegacyDeployment(spinner: Ora): Promise<LegacyInfo>;
+/**
+ * Migrate legacy Trinity deployment from `trinity/` to `.claude/trinity/`
+ * Preserves user-managed knowledge base files during migration
+ * @param spinner - ora spinner instance for status display
+ */
+export declare function migrateLegacyDeployment(spinner: Ora): Promise<void>;
+/**
+ * Update .gitignore to replace old Trinity patterns with current ones
+ * Safe to run on any deployment — idempotent
+ * @param spinner - ora spinner instance for status display
+ * @returns True if gitignore was updated
+ */
+export declare function updateGitignoreForMigration(spinner: Ora): Promise<boolean>;
+//# sourceMappingURL=migration.d.ts.map

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

@@ -0,0 +1,130 @@
+/**
+ * Update Migration Module
+ * Handles legacy deployment detection and migration from pre-2.2.0 structure
+ * @module cli/commands/update/migration
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import { validatePath } from '../../utils/validate-path.js';
+/** Old gitignore patterns from pre-2.2.0 deployments */
+const OLD_GITIGNORE_PATTERNS = ['trinity/', '*CLAUDE.md', 'TRINITY.md'];
+/** Current gitignore patterns */
+const CURRENT_GITIGNORE_PATTERNS = [
+    '.claude/trinity/archive/',
+    '.claude/trinity/templates/',
+    '*CLAUDE.md',
+];
+/**
+ * Detect if the project has a legacy (pre-2.2.0) Trinity deployment
+ * Legacy deployments use `trinity/` at root instead of `.claude/trinity/`
+ * @param spinner - ora spinner instance for status display
+ * @returns Legacy deployment info
+ */
+export async function detectLegacyDeployment(spinner) {
+    spinner.start('Checking for legacy deployment...');
+    const hasLegacyDir = await fs.pathExists('trinity');
+    const hasLegacyVersion = await fs.pathExists('trinity/VERSION');
+    if (!hasLegacyDir) {
+        spinner.info('No legacy deployment detected');
+        return { isLegacy: false, legacyVersion: null };
+    }
+    let legacyVersion = null;
+    if (hasLegacyVersion) {
+        legacyVersion = (await fs.readFile('trinity/VERSION', 'utf8')).trim();
+    }
+    spinner.warn(`Legacy deployment detected (v${legacyVersion || 'unknown'})`);
+    return { isLegacy: true, legacyVersion };
+}
+/**
+ * Migrate legacy Trinity deployment from `trinity/` to `.claude/trinity/`
+ * Preserves user-managed knowledge base files during migration
+ * @param spinner - ora spinner instance for status display
+ */
+export async function migrateLegacyDeployment(spinner) {
+    spinner.start('Migrating legacy deployment to .claude/trinity/...');
+    // Create new directory structure
+    await fs.ensureDir('.claude/trinity');
+    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');
+    await fs.ensureDir('.claude/commands');
+    // Move trinity/ contents to .claude/trinity/
+    const trinityContents = await fs.readdir('trinity');
+    for (const item of trinityContents) {
+        const srcPath = path.join('trinity', item);
+        const destPath = path.join('.claude/trinity', item);
+        // Don't overwrite if destination already exists (prefer new structure)
+        if (!(await fs.pathExists(destPath))) {
+            await fs.copy(srcPath, destPath);
+        }
+    }
+    // Remove old trinity/ directory
+    await fs.remove('trinity');
+    spinner.succeed('Legacy deployment migrated to .claude/trinity/');
+}
+/**
+ * Update .gitignore to replace old Trinity patterns with current ones
+ * Safe to run on any deployment — idempotent
+ * @param spinner - ora spinner instance for status display
+ * @returns True if gitignore was updated
+ */
+export async function updateGitignoreForMigration(spinner) {
+    spinner.start('Updating .gitignore patterns...');
+    const gitignorePath = '.gitignore';
+    if (!(await fs.pathExists(gitignorePath))) {
+        spinner.info('No .gitignore found, skipping');
+        return false;
+    }
+    let content = await fs.readFile(gitignorePath, 'utf8');
+    const originalContent = content;
+    if (content.includes('# Trinity Method SDK')) {
+        // Remove the existing Trinity section entirely
+        const lines = content.split('\n');
+        const filteredLines = [];
+        let inTrinitySection = false;
+        for (const line of lines) {
+            if (line.trim() === '# Trinity Method SDK') {
+                inTrinitySection = true;
+                continue;
+            }
+            // End of Trinity section: next comment or blank line after non-Trinity content
+            if (inTrinitySection) {
+                const trimmed = line.trim();
+                // Still in Trinity section if line is empty, or matches known patterns
+                if (trimmed === '' ||
+                    trimmed === 'trinity/' ||
+                    trimmed === '*CLAUDE.md' ||
+                    trimmed === 'TRINITY.md' ||
+                    trimmed === '.claude/trinity/archive/' ||
+                    trimmed === '.claude/trinity/templates/') {
+                    continue;
+                }
+                // Non-Trinity line — we've left the section
+                inTrinitySection = false;
+            }
+            filteredLines.push(line);
+        }
+        content = filteredLines.join('\n');
+    }
+    // Remove any standalone old patterns that might exist outside the section
+    for (const pattern of OLD_GITIGNORE_PATTERNS) {
+        const regex = new RegExp(`^${pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*$`, 'gm');
+        content = content.replace(regex, '');
+    }
+    // Clean up multiple blank lines
+    content = content.replace(/\n{3,}/g, '\n\n').trim();
+    // Append current Trinity section
+    const trinitySection = ['', '# Trinity Method SDK', ...CURRENT_GITIGNORE_PATTERNS].join('\n');
+    content = `${content}\n${trinitySection}\n`;
+    if (content === originalContent) {
+        spinner.info('.gitignore already up to date');
+        return false;
+    }
+    const validatedPath = validatePath(gitignorePath);
+    await fs.writeFile(validatedPath, content);
+    spinner.succeed('.gitignore patterns updated');
+    return true;
+}
+//# sourceMappingURL=migration.js.map

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

@@ -4,10 +4,15 @@
  * @module cli/commands/update/pre-flight
  */
 import { Ora } from 'ora';
+export interface PreflightResult {
+    needsLegacyMigration: boolean;
+}
 /**
  * Run pre-flight checks to ensure Trinity Method is deployed
+ * Detects both current (.claude/trinity/) and legacy (trinity/) layouts
  * @param spinner - ora spinner instance for status display
- * @throws {UpdateError} If pre-flight checks fail
+ * @returns Pre-flight result with migration flags
+ * @throws {UpdateError} If no Trinity deployment found at all
  */
-export declare function runUpdatePreflightChecks(spinner: Ora): Promise<void>;
+export declare function runUpdatePreflightChecks(spinner: Ora): Promise<PreflightResult>;
 //# sourceMappingURL=pre-flight.d.ts.map

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

@@ -7,31 +7,32 @@ import fs from 'fs-extra';
 import { UpdateError } from '../../utils/error-classes.js';
 /**
  * Run pre-flight checks to ensure Trinity Method is deployed
+ * Detects both current (.claude/trinity/) and legacy (trinity/) layouts
  * @param spinner - ora spinner instance for status display
- * @throws {UpdateError} If pre-flight checks fail
+ * @returns Pre-flight result with migration flags
+ * @throws {UpdateError} If no Trinity deployment found at all
  */
 export async function runUpdatePreflightChecks(spinner) {
     spinner.start('Running pre-flight checks...');
-    // 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('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',
-        });
+    const legacyExists = await fs.pathExists('trinity');
+    // Current structure found — no migration needed
+    if (claudeExists && trinityExists) {
+        spinner.succeed('Pre-flight checks passed');
+        return { needsLegacyMigration: false };
+    }
+    // Legacy structure found — migration needed
+    if (legacyExists) {
+        spinner.succeed('Pre-flight checks passed (legacy deployment detected)');
+        return { needsLegacyMigration: true };
     }
-    spinner.succeed('Pre-flight checks passed');
+    // Neither found — not deployed
+    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',
+    });
 }
 //# sourceMappingURL=pre-flight.js.map

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

@@ -18,6 +18,12 @@ export function displayUpdateSummary(stats, oldVersion, newVersion) {
     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}`));
+    if (stats.legacyMigrated) {
+        console.log(chalk.yellow(`   Legacy Migration: trinity/ → .claude/trinity/`));
+    }
+    if (stats.gitignoreUpdated) {
+        console.log(chalk.white(`   .gitignore: Updated`));
+    }
     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`));

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

@@ -9,5 +9,7 @@ export interface UpdateStats {
     knowledgeBaseUpdated: number;
     commandsUpdated: number;
     filesUpdated: number;
+    legacyMigrated: boolean;
+    gitignoreUpdated: boolean;
 }
 //# sourceMappingURL=types.d.ts.map

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

@@ -13,11 +13,13 @@ 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 = '.claude/trinity/VERSION';
+    // Read current version from .claude/trinity/VERSION (or legacy trinity/VERSION)
     let currentVersion = '0.0.0';
-    if (await fs.pathExists(versionPath)) {
-        currentVersion = (await fs.readFile(versionPath, 'utf8')).trim();
+    if (await fs.pathExists('.claude/trinity/VERSION')) {
+        currentVersion = (await fs.readFile('.claude/trinity/VERSION', 'utf8')).trim();
+    }
+    else if (await fs.pathExists('trinity/VERSION')) {
+        currentVersion = (await fs.readFile('trinity/VERSION', 'utf8')).trim();
     }
     // Read latest version from SDK package.json
     const sdkPkgPath = await getPackageJsonPath();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trinity-method-sdk",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "Trinity Method SDK - Investigation-first development methodology for any project",
   "type": "module",
   "main": "dist/index.js",