@oamm/textor 1.0.8 → 1.0.9

package/README.md

@@ -279,6 +279,20 @@ pnpm textor normalize-state
 **Options:**
 - `--dry-run`: Print the normalized state without writing it.
 
+### prune-missing
+Remove missing references from Textor state. This command identifies files that are tracked in the state but are no longer present on disk and removes them from `.textor/state.json`. 
+
+**Safe-by-default**: This command never deletes any files from your disk; it only updates the state tracker.
+
+```bash
+pnpm textor prune-missing
+```
+
+**Options:**
+- `--dry-run`: Preview what would be removed from the state without making changes.
+- `--yes`: Skip confirmation prompt.
+- `--no-interactive`: Disable interactive prompts (useful for CI).
+
 ## 🏗️ Technical Architecture
 
 Textor is designed with enterprise-grade robustness, moving beyond simple scaffolding to provide a reliable refactoring engine.

package/dist/bin/textor.js

@@ -6,6 +6,7 @@ import path from 'path';
 import { createHash } from 'crypto';
 import { exec } from 'child_process';
 import { promisify } from 'util';
+import readline from 'readline';
 
 const CONFIG_DIR$1 = '.textor';
 const CONFIG_FILE = 'config.json';
@@ -3844,67 +3845,87 @@ async function validateStateCommand(options) {
   }
 }
 
-async function statusCommand() {
-  try {
-    const config = await loadConfig();
-    const state = await loadState();
-    
-    const results = {
-      missing: [],
-      modified: [],
-      untracked: [], // Has signature, not in state
-      orphaned: [],  // No signature, not in state
-      synced: 0
-    };
+/**
+ * Computes the drift between the state and the actual files on disk.
+ * 
+ * @param {import('./config.js').TextorConfig} config 
+ * @param {Object} state 
+ * @returns {Promise<{
+ *   missing: string[],
+ *   modified: string[],
+ *   untracked: string[],
+ *   orphaned: string[],
+ *   synced: number
+ * }>}
+ */
+async function getProjectStatus(config, state) {
+  const results = {
+    missing: [],
+    modified: [],
+    untracked: [], // Has signature, not in state
+    orphaned: [],  // No signature, not in state
+    synced: 0
+  };
 
-    const roots = [
-      resolvePath(config, 'pages'),
-      resolvePath(config, 'features'),
-      resolvePath(config, 'components')
-    ].map(p => path.resolve(p));
+  const roots = [
+    resolvePath(config, 'pages'),
+    resolvePath(config, 'features'),
+    resolvePath(config, 'components')
+  ].map(p => path.resolve(p));
 
-    const diskFiles = new Set();
-    const configSignatures = Object.values(config.signatures || {});
+  const diskFiles = new Set();
+  const configSignatures = Object.values(config.signatures || {});
 
-    for (const root of roots) {
-      if (existsSync(root)) {
-        await scanDirectory(root, diskFiles);
-      }
+  for (const root of roots) {
+    if (existsSync(root)) {
+      await scanDirectory(root, diskFiles);
     }
+  }
 
-    // 1. Check state files against disk
-    for (const relativePath in state.files) {
-      const fullPath = path.join(process.cwd(), relativePath);
-      
-      if (!existsSync(fullPath)) {
-        results.missing.push(relativePath);
-        continue;
-      }
+  // 1. Check state files against disk
+  for (const relativePath in state.files) {
+    const fullPath = path.join(process.cwd(), relativePath);
+    
+    if (!existsSync(fullPath)) {
+      results.missing.push(relativePath);
+      continue;
+    }
 
-      diskFiles.delete(relativePath);
+    // It exists on disk, so it's not untracked/orphaned
+    diskFiles.delete(relativePath);
 
-      const content = await readFile(fullPath, 'utf-8');
-      const currentHash = calculateHash(content, config.hashing?.normalization);
-      const fileData = state.files[relativePath];
+    const content = await readFile(fullPath, 'utf-8');
+    const currentHash = calculateHash(content, config.hashing?.normalization);
+    const fileData = state.files[relativePath];
 
-      if (currentHash !== fileData.hash) {
-        results.modified.push(relativePath);
-      } else {
-        results.synced++;
-      }
+    if (currentHash !== fileData.hash) {
+      results.modified.push(relativePath);
+    } else {
+      results.synced++;
     }
+  }
 
-    // 2. Check remaining disk files
-    for (const relativePath of diskFiles) {
-      const fullPath = path.join(process.cwd(), relativePath);
-      const isGenerated = await isTextorGenerated(fullPath, configSignatures);
-      
-      if (isGenerated) {
-        results.untracked.push(relativePath);
-      } else {
-        results.orphaned.push(relativePath);
-      }
+  // 2. Check remaining disk files
+  for (const relativePath of diskFiles) {
+    const fullPath = path.join(process.cwd(), relativePath);
+    const isGenerated = await isTextorGenerated(fullPath, configSignatures);
+    
+    if (isGenerated) {
+      results.untracked.push(relativePath);
+    } else {
+      results.orphaned.push(relativePath);
     }
+  }
+
+  return results;
+}
+
+async function statusCommand() {
+  try {
+    const config = await loadConfig();
+    const state = await loadState();
+    
+    const results = await getProjectStatus(config, state);
 
     // Reporting
     console.log('Textor Status Report:');
@@ -4329,6 +4350,71 @@ async function normalizeStateCommand(options) {
   }
 }
 
+/**
+ * Removes missing references from Textor state.
+ * @param {Object} options 
+ * @param {boolean} options.dryRun 
+ * @param {boolean} options.yes 
+ */
+async function pruneMissingCommand(options = {}) {
+  try {
+    const config = await loadConfig();
+    const state = await loadState();
+    
+    const results = await getProjectStatus(config, state);
+    
+    if (results.missing.length === 0) {
+      console.log('No missing references found.');
+      return;
+    }
+
+    console.log(`Found ${results.missing.length} missing references:`);
+    results.missing.forEach(f => console.log(`  - ${f}`));
+
+    if (options.dryRun) {
+      console.log('\nDry run: no changes applied to state.');
+      return;
+    }
+
+    if (!options.yes && options.interactive !== false && process.stdin.isTTY && process.env.NODE_ENV !== 'test') {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+
+      const confirmed = await new Promise(resolve => {
+        rl.question('\nDo you want to proceed with pruning? (y/N) ', (answer) => {
+          rl.close();
+          resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+        });
+      });
+
+      if (!confirmed) {
+        console.log('Aborted.');
+        return;
+      }
+    }
+
+    for (const relPath of results.missing) {
+      delete state.files[relPath];
+    }
+
+    // Reconstruct metadata
+    state.components = reconstructComponents(state.files, config);
+    state.sections = reconstructSections(state, config);
+
+    await saveState(state);
+    console.log(`\n✓ Successfully removed ${results.missing.length} missing references from state.`);
+
+  } catch (error) {
+    console.error('Error:', error.message);
+    if (typeof process.exit === 'function' && process.env.NODE_ENV !== 'test') {
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+
 const program = new Command();
 
 program
@@ -4466,5 +4552,13 @@ program
   .option('--dry-run', 'Show the normalized state without writing to disk')
   .action(normalizeStateCommand);
 
+program
+  .command('prune-missing')
+  .description('Remove missing files from state (files that are in state but not on disk)')
+  .option('--dry-run', 'Show what would be removed without applying')
+  .option('--yes', 'Skip confirmation')
+  .option('--no-interactive', 'Disable interactive prompts')
+  .action(pruneMissingCommand);
+
 program.parse();
 //# sourceMappingURL=textor.js.map

package/dist/bin/textor.js.map

@@ -1 +1 @@
-{"version":3,"file":"textor.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"textor.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.cjs

@@ -3208,58 +3208,77 @@ async function validateStateCommand(options) {
     }
 }
 
+/**
+ * Computes the drift between the state and the actual files on disk.
+ *
+ * @param {import('./config.js').TextorConfig} config
+ * @param {Object} state
+ * @returns {Promise<{
+ *   missing: string[],
+ *   modified: string[],
+ *   untracked: string[],
+ *   orphaned: string[],
+ *   synced: number
+ * }>}
+ */
+async function getProjectStatus(config, state) {
+    const results = {
+        missing: [],
+        modified: [],
+        untracked: [], // Has signature, not in state
+        orphaned: [], // No signature, not in state
+        synced: 0
+    };
+    const roots = [
+        resolvePath(config, 'pages'),
+        resolvePath(config, 'features'),
+        resolvePath(config, 'components')
+    ].map(p => path.resolve(p));
+    const diskFiles = new Set();
+    const configSignatures = Object.values(config.signatures || {});
+    for (const root of roots) {
+        if (fs.existsSync(root)) {
+            await scanDirectory(root, diskFiles);
+        }
+    }
+    // 1. Check state files against disk
+    for (const relativePath in state.files) {
+        const fullPath = path.join(process.cwd(), relativePath);
+        if (!fs.existsSync(fullPath)) {
+            results.missing.push(relativePath);
+            continue;
+        }
+        // It exists on disk, so it's not untracked/orphaned
+        diskFiles.delete(relativePath);
+        const content = await promises.readFile(fullPath, 'utf-8');
+        const currentHash = calculateHash(content, config.hashing?.normalization);
+        const fileData = state.files[relativePath];
+        if (currentHash !== fileData.hash) {
+            results.modified.push(relativePath);
+        }
+        else {
+            results.synced++;
+        }
+    }
+    // 2. Check remaining disk files
+    for (const relativePath of diskFiles) {
+        const fullPath = path.join(process.cwd(), relativePath);
+        const isGenerated = await isTextorGenerated(fullPath, configSignatures);
+        if (isGenerated) {
+            results.untracked.push(relativePath);
+        }
+        else {
+            results.orphaned.push(relativePath);
+        }
+    }
+    return results;
+}
+
 async function statusCommand() {
     try {
         const config = await loadConfig();
         const state = await loadState();
-        const results = {
-            missing: [],
-            modified: [],
-            untracked: [], // Has signature, not in state
-            orphaned: [], // No signature, not in state
-            synced: 0
-        };
-        const roots = [
-            resolvePath(config, 'pages'),
-            resolvePath(config, 'features'),
-            resolvePath(config, 'components')
-        ].map(p => path.resolve(p));
-        const diskFiles = new Set();
-        const configSignatures = Object.values(config.signatures || {});
-        for (const root of roots) {
-            if (fs.existsSync(root)) {
-                await scanDirectory(root, diskFiles);
-            }
-        }
-        // 1. Check state files against disk
-        for (const relativePath in state.files) {
-            const fullPath = path.join(process.cwd(), relativePath);
-            if (!fs.existsSync(fullPath)) {
-                results.missing.push(relativePath);
-                continue;
-            }
-            diskFiles.delete(relativePath);
-            const content = await promises.readFile(fullPath, 'utf-8');
-            const currentHash = calculateHash(content, config.hashing?.normalization);
-            const fileData = state.files[relativePath];
-            if (currentHash !== fileData.hash) {
-                results.modified.push(relativePath);
-            }
-            else {
-                results.synced++;
-            }
-        }
-        // 2. Check remaining disk files
-        for (const relativePath of diskFiles) {
-            const fullPath = path.join(process.cwd(), relativePath);
-            const isGenerated = await isTextorGenerated(fullPath, configSignatures);
-            if (isGenerated) {
-                results.untracked.push(relativePath);
-            }
-            else {
-                results.orphaned.push(relativePath);
-            }
-        }
+        const results = await getProjectStatus(config, state);
         // Reporting
         console.log('Textor Status Report:');
         console.log(`  Synced files: ${results.synced}`);