tribunal-kit 9.2.5 → 9.2.6

package/src/utils/fs.js

@@ -1,80 +1,84 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+'use strict';
+const __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.copyDir = copyDir;
 exports.countDir = countDir;
 exports.isSelfInstall = isSelfInstall;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const logger_1 = require("./logger");
+const fs_1 = __importDefault(require('fs'));
+const path_1 = __importDefault(require('path'));
+const logger_1 = require('./logger');
 // Concurrency limit for parallel file operations to avoid fd exhaustion
 const COPY_CONCURRENCY = 32;
 
 async function copyDir(src, dest, dryRun = false, filter = null, currentDepth = 0) {
-    if (currentDepth > 20) {
-        throw new Error(`Maximum directory copy depth (20) exceeded at: ${src}`);
-    }
-    if (!dryRun) {
-        await fs_1.default.promises.mkdir(dest, { recursive: true });
-    }
-    const entries = await fs_1.default.promises.readdir(src, { withFileTypes: true });
-    let count = 0;
-    const dirs = [];
-    const files = [];
+  if (currentDepth > 20) {
+    throw new Error(`Maximum directory copy depth (20) exceeded at: ${src}`);
+  }
+  if (!dryRun) {
+    await fs_1.default.promises.mkdir(dest, { recursive: true });
+  }
+  const entries = await fs_1.default.promises.readdir(src, { withFileTypes: true });
+  let count = 0;
+  const dirs = [];
+  const files = [];
 
-    for (const entry of entries) {
-        // Apply filter if provided (for --minimal mode or incremental copy)
-        if (filter && !filter(entry.name, src, entry.isDirectory())) {
-            (0, logger_1.dbg)(`  skip: ${entry.name}`);
-            continue;
-        }
-        const srcPath = path_1.default.join(src, entry.name);
-        const destPath = path_1.default.join(dest, entry.name);
-        if (entry.isDirectory()) {
-            dirs.push({ srcPath, destPath });
-        }
-        else {
-            files.push({ srcPath, destPath, name: entry.name });
-        }
+  for (const entry of entries) {
+    // Apply filter if provided (for --minimal mode or incremental copy)
+    if (filter && !filter(entry.name, src, entry.isDirectory())) {
+      (0, logger_1.dbg)(`  skip: ${entry.name}`);
+      continue;
     }
-
-    // Copy files in parallel batches
-    for (let i = 0; i < files.length; i += COPY_CONCURRENCY) {
-        const batch = files.slice(i, i + COPY_CONCURRENCY);
-        await Promise.all(batch.map(async ({ srcPath, destPath, name }) => {
-            if (!dryRun) {
-                await fs_1.default.promises.copyFile(srcPath, destPath);
-            }
-            (0, logger_1.dbg)(`  copy: ${name}`);
-        }));
-        count += batch.length;
+    const srcPath = path_1.default.join(src, entry.name);
+    const destPath = path_1.default.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      dirs.push({ srcPath, destPath });
+    } else {
+      files.push({ srcPath, destPath, name: entry.name });
     }
+  }
 
-    // Recurse into directories in parallel (dirs are I/O-independent)
-    const dirResults = await Promise.all(
-        dirs.map(({ srcPath, destPath }) => copyDir(srcPath, destPath, dryRun, filter, currentDepth + 1))
+  // Copy files in parallel batches
+  for (let i = 0; i < files.length; i += COPY_CONCURRENCY) {
+    const batch = files.slice(i, i + COPY_CONCURRENCY);
+    await Promise.all(
+      batch.map(async ({ srcPath, destPath, name }) => {
+        if (!dryRun) {
+          await fs_1.default.promises.copyFile(srcPath, destPath);
+        }
+        (0, logger_1.dbg)(`  copy: ${name}`);
+      }),
     );
-    for (const dirCount of dirResults) {
-        count += dirCount;
-    }
+    count += batch.length;
+  }
+
+  // Recurse into directories in parallel (dirs are I/O-independent)
+  const dirResults = await Promise.all(
+    dirs.map(({ srcPath, destPath }) =>
+      copyDir(srcPath, destPath, dryRun, filter, currentDepth + 1),
+    ),
+  );
+  for (const dirCount of dirResults) {
+    count += dirCount;
+  }
 
-    return count;
+  return count;
 }
 async function countDir(dir, currentDepth = 0) {
-    if (currentDepth > 20) {
-        throw new Error(`Maximum directory count depth (20) exceeded at: ${dir}`);
-    }
-    let count = 0;
-    const entries = await fs_1.default.promises.readdir(dir, { withFileTypes: true });
-    for (const e of entries) {
-        if (e.isDirectory())
-            count += await countDir(path_1.default.join(dir, e.name), currentDepth + 1);
-        else
-            count++;
-    }
-    return count;
+  if (currentDepth > 20) {
+    throw new Error(`Maximum directory count depth (20) exceeded at: ${dir}`);
+  }
+  let count = 0;
+  const entries = await fs_1.default.promises.readdir(dir, { withFileTypes: true });
+  for (const e of entries) {
+    if (e.isDirectory())
+      count += await countDir(path_1.default.join(dir, e.name), currentDepth + 1);
+    else count++;
+  }
+  return count;
 }
 /**
  * Returns true if the target directory IS the tribunal-kit package itself.
@@ -82,21 +86,18 @@ async function countDir(dir, currentDepth = 0) {
  * when run from inside the project directory.
  */
 function isSelfInstall(targetDir, pkgName, kitRoot) {
-    const resolvedTarget = path_1.default.resolve(targetDir);
-    // Direct path match
-    if (resolvedTarget === kitRoot)
-        return true;
-    // Check if the target's package.json is this package
-    const targetPkg = path_1.default.join(resolvedTarget, 'package.json');
-    if (fs_1.default.existsSync(targetPkg)) {
-        try {
-            const targetName = JSON.parse(fs_1.default.readFileSync(targetPkg, 'utf8')).name;
-            if (targetName === pkgName)
-                return true;
-        }
-        catch {
-            // Unreadable package.json — not a match
-        }
+  const resolvedTarget = path_1.default.resolve(targetDir);
+  // Direct path match
+  if (resolvedTarget === kitRoot) return true;
+  // Check if the target's package.json is this package
+  const targetPkg = path_1.default.join(resolvedTarget, 'package.json');
+  if (fs_1.default.existsSync(targetPkg)) {
+    try {
+      const targetName = JSON.parse(fs_1.default.readFileSync(targetPkg, 'utf8')).name;
+      if (targetName === pkgName) return true;
+    } catch {
+      // Unreadable package.json — not a match
     }
-    return false;
+  }
+  return false;
 }

package/src/utils/hasher.js

@@ -1,15 +1,17 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+'use strict';
+const __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.generateManifest = generateManifest;
 exports.readManifest = readManifest;
 exports.writeManifest = writeManifest;
 exports.diffManifests = diffManifests;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require('fs'));
+const path_1 = __importDefault(require('path'));
+const crypto_1 = __importDefault(require('crypto'));
 
 const MANIFEST_FILE = '.manifest.json';
 
@@ -18,70 +20,70 @@ const MANIFEST_FILE = '.manifest.json';
  * Uses streaming to handle large files without high memory usage.
  */
 async function hashFile(filePath) {
-    return new Promise((resolve, reject) => {
-        const hash = crypto_1.default.createHash('sha256');
-        const stream = fs_1.default.createReadStream(filePath);
-        stream.on('data', (chunk) => hash.update(chunk));
-        stream.on('end', () => resolve(hash.digest('hex')));
-        stream.on('error', reject);
-    });
+  return new Promise((resolve, reject) => {
+    const hash = crypto_1.default.createHash('sha256');
+    const stream = fs_1.default.createReadStream(filePath);
+    stream.on('data', chunk => hash.update(chunk));
+    stream.on('end', () => resolve(hash.digest('hex')));
+    stream.on('error', reject);
+  });
 }
 
 /**
  * Walk a directory recursively and generate a hash manifest.
  * Returns an object mapping relative file paths to their SHA-256 hashes.
- * 
+ *
  * @param {string} dir - The directory to walk
  * @param {string} [baseDir] - The base directory for computing relative paths
  * @returns {Promise<Record<string, string>>} Map of relative paths to SHA-256 hashes
  */
 async function generateManifest(dir, baseDir) {
-    if (!baseDir) baseDir = dir;
-    const manifest = {};
-
-    if (!fs_1.default.existsSync(dir)) return manifest;
-
-    const entries = await fs_1.default.promises.readdir(dir, { withFileTypes: true });
-
-    // Process files in parallel batches
-    const BATCH_SIZE = 32;
-    const files = [];
-    const dirs = [];
-
-    for (const entry of entries) {
-        const fullPath = path_1.default.join(dir, entry.name);
-        if (entry.name === '.backups' || entry.name === '.manifest.json' || entry.name === 'history') {
-            continue; // Skip backup dirs, manifest, and history
-        }
-        if (entry.isDirectory()) {
-            dirs.push(fullPath);
-        } else {
-            files.push(fullPath);
-        }
-    }
+  if (!baseDir) baseDir = dir;
+  const manifest = {};
 
-    // Hash files in parallel batches
-    for (let i = 0; i < files.length; i += BATCH_SIZE) {
-        const batch = files.slice(i, i + BATCH_SIZE);
-        const results = await Promise.all(batch.map(async (filePath) => {
-            const relativePath = path_1.default.relative(baseDir, filePath).replace(/\\/g, '/');
-            const hash = await hashFile(filePath);
-            return { relativePath, hash };
-        }));
-        for (const { relativePath, hash } of results) {
-            manifest[relativePath] = hash;
-        }
-    }
+  if (!fs_1.default.existsSync(dir)) return manifest;
+
+  const entries = await fs_1.default.promises.readdir(dir, { withFileTypes: true });
+
+  // Process files in parallel batches
+  const BATCH_SIZE = 32;
+  const files = [];
+  const dirs = [];
 
-    // Recurse into directories in parallel
-    const dirResults = await Promise.all(
-        dirs.map(d => generateManifest(d, baseDir))
+  for (const entry of entries) {
+    const fullPath = path_1.default.join(dir, entry.name);
+    if (entry.name === '.backups' || entry.name === '.manifest.json' || entry.name === 'history') {
+      continue; // Skip backup dirs, manifest, and history
+    }
+    if (entry.isDirectory()) {
+      dirs.push(fullPath);
+    } else {
+      files.push(fullPath);
+    }
+  }
+
+  // Hash files in parallel batches
+  for (let i = 0; i < files.length; i += BATCH_SIZE) {
+    const batch = files.slice(i, i + BATCH_SIZE);
+    const results = await Promise.all(
+      batch.map(async filePath => {
+        const relativePath = path_1.default.relative(baseDir, filePath).replace(/\\/g, '/');
+        const hash = await hashFile(filePath);
+        return { relativePath, hash };
+      }),
     );
-    for (const dirManifest of dirResults) {
-        Object.assign(manifest, dirManifest);
+    for (const { relativePath, hash } of results) {
+      manifest[relativePath] = hash;
     }
+  }
 
-    return manifest;
+  // Recurse into directories in parallel
+  const dirResults = await Promise.all(dirs.map(d => generateManifest(d, baseDir)));
+  for (const dirManifest of dirResults) {
+    Object.assign(manifest, dirManifest);
+  }
+
+  return manifest;
 }
 
 /**
@@ -89,54 +91,54 @@ async function generateManifest(dir, baseDir) {
  * Returns null if no manifest exists.
  */
 function readManifest(agentDir) {
-    const manifestPath = path_1.default.join(agentDir, MANIFEST_FILE);
-    try {
-        if (!fs_1.default.existsSync(manifestPath)) return null;
-        const raw = fs_1.default.readFileSync(manifestPath, 'utf8');
-        return JSON.parse(raw);
-    } catch {
-        return null;
-    }
+  const manifestPath = path_1.default.join(agentDir, MANIFEST_FILE);
+  try {
+    if (!fs_1.default.existsSync(manifestPath)) return null;
+    const raw = fs_1.default.readFileSync(manifestPath, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
 }
 
 /**
  * Write a manifest to the .agent directory.
  */
 function writeManifest(agentDir, manifest) {
-    const manifestPath = path_1.default.join(agentDir, MANIFEST_FILE);
-    fs_1.default.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf8');
+  const manifestPath = path_1.default.join(agentDir, MANIFEST_FILE);
+  fs_1.default.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf8');
 }
 
 /**
  * Compare two manifests and return the diff.
- * 
+ *
  * @param {Record<string, string>} oldManifest - Previously installed manifest
  * @param {Record<string, string>} newManifest - Source manifest
  * @returns {{ added: string[], changed: string[], removed: string[], unchanged: number }}
  */
 function diffManifests(oldManifest, newManifest) {
-    const added = [];
-    const changed = [];
-    const removed = [];
-    let unchanged = 0;
-
-    // Find added and changed files
-    for (const [path, hash] of Object.entries(newManifest)) {
-        if (!(path in oldManifest)) {
-            added.push(path);
-        } else if (oldManifest[path] !== hash) {
-            changed.push(path);
-        } else {
-            unchanged++;
-        }
+  const added = [];
+  const changed = [];
+  const removed = [];
+  let unchanged = 0;
+
+  // Find added and changed files
+  for (const [path, hash] of Object.entries(newManifest)) {
+    if (!(path in oldManifest)) {
+      added.push(path);
+    } else if (oldManifest[path] !== hash) {
+      changed.push(path);
+    } else {
+      unchanged++;
     }
+  }
 
-    // Find removed files
-    for (const path of Object.keys(oldManifest)) {
-        if (!(path in newManifest)) {
-            removed.push(path);
-        }
+  // Find removed files
+  for (const path of Object.keys(oldManifest)) {
+    if (!(path in newManifest)) {
+      removed.push(path);
     }
+  }
 
-    return { added, changed, removed, unchanged };
+  return { added, changed, removed, unchanged };
 }

package/src/utils/helpers.js

@@ -1,53 +1,52 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+'use strict';
+const __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.runShellAsync = runShellAsync;
 exports.getKitAgent = getKitAgent;
 exports.banner = banner;
-const child_process_1 = require("child_process");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const logger_1 = require("./logger");
+const child_process_1 = require('child_process');
+const fs_1 = __importDefault(require('fs'));
+const path_1 = __importDefault(require('path'));
+const logger_1 = require('./logger');
 function runShellAsync(command, args = [], options = {}) {
-    return new Promise((resolve, reject) => {
-        const timeoutMs = (options && options.timeout) || 120000;
-        const child = (0, child_process_1.spawn)(command, args, { ...options, shell: false });
-        const timer = setTimeout(() => {
-            child.kill('SIGTERM');
-            reject(new Error(`Command timed out after ${timeoutMs}ms: ${command}`));
-        }, timeoutMs);
-        child.on('close', code => {
-            clearTimeout(timer);
-            if (code !== 0)
-                reject(new Error(`Command failed with exit code ${code}`));
-            else
-                resolve();
-        });
-        child.on('error', err => {
-            clearTimeout(timer);
-            reject(err);
-        });
+  return new Promise((resolve, reject) => {
+    const timeoutMs = (options && options.timeout) || 120000;
+    const child = (0, child_process_1.spawn)(command, args, { ...options, shell: false });
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM');
+      reject(new Error(`Command timed out after ${timeoutMs}ms: ${command}`));
+    }, timeoutMs);
+    child.on('close', code => {
+      clearTimeout(timer);
+      if (code !== 0) reject(new Error(`Command failed with exit code ${code}`));
+      else resolve();
     });
+    child.on('error', err => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
 }
 function getKitAgent() {
-    // When installed via npm, the .agent/ folder is next to this script's package (two directories up from src/commands)
-    // In src/utils, __dirname is .../src/utils. We go up to src, then to root. So path.resolve(__dirname, '../../.agent')
-    const kitRoot = path_1.default.resolve(__dirname, '../..');
-    const agentDir = path_1.default.join(kitRoot, '.agent');
-    if (!fs_1.default.existsSync(agentDir)) {
-        (0, logger_1.err)(`Kit .agent/ folder not found at: ${agentDir}`);
-        (0, logger_1.err)('The package may be corrupted. Try: npm install -g tribunal-kit');
-        process.exit(1);
-    }
-    return agentDir;
+  // When installed via npm, the .agent/ folder is next to this script's package (two directories up from src/commands)
+  // In src/utils, __dirname is .../src/utils. We go up to src, then to root. So path.resolve(__dirname, '../../.agent')
+  const kitRoot = path_1.default.resolve(__dirname, '../..');
+  const agentDir = path_1.default.join(kitRoot, '.agent');
+  if (!fs_1.default.existsSync(agentDir)) {
+    (0, logger_1.err)(`Kit .agent/ folder not found at: ${agentDir}`);
+    (0, logger_1.err)('The package may be corrupted. Try: npm install -g tribunal-kit');
+    process.exit(1);
+  }
+  return agentDir;
 }
 const { renderBanner } = require('../tui/banner');
 
 function banner(quiet) {
-    if (quiet) return;
-    const PKG = require('../../package.json');
-    renderBanner(PKG.version, quiet);
+  if (quiet) return;
+  const PKG = require('../../package.json');
+  renderBanner(PKG.version, quiet);
 }
-

package/src/utils/logger.js

@@ -1,5 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.C = void 0;
 exports.colorize = colorize;
 exports.c = c;
@@ -13,42 +13,49 @@ exports.dim = dim;
 exports.dbg = dbg;
 // src/utils/logger.ts
 exports.C = {
-    reset: '\x1b[0m',
-    bold: '\x1b[1m',
-    dim: '\x1b[2m',
-    red: '\x1b[91m',
-    green: '\x1b[92m',
-    yellow: '\x1b[93m',
-    blue: '\x1b[94m',
-    magenta: '\x1b[95m',
-    cyan: '\x1b[96m',
-    white: '\x1b[97m',
-    gray: '\x1b[90m',
-    bgCyan: '\x1b[46m',
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[91m',
+  green: '\x1b[92m',
+  yellow: '\x1b[93m',
+  blue: '\x1b[94m',
+  magenta: '\x1b[95m',
+  cyan: '\x1b[96m',
+  white: '\x1b[97m',
+  gray: '\x1b[90m',
+  bgCyan: '\x1b[46m',
 };
 function colorize(color, text) {
-    return `${exports.C[color]}${text}${exports.C.reset}`;
+  return `${exports.C[color]}${text}${exports.C.reset}`;
 }
 function c(color, text) {
-    return `${exports.C[color]}${text}${exports.C.reset}`;
+  return `${exports.C[color]}${text}${exports.C.reset}`;
 }
 function bold(text) {
-    return `${exports.C.bold}${text}${exports.C.reset}`;
+  return `${exports.C.bold}${text}${exports.C.reset}`;
 }
 let quiet = false;
 let verbose = false;
 function setLogLevels(q, v) {
-    quiet = q;
-    verbose = v;
-}
-function log(msg) { if (!quiet)
-    console.log(msg); }
-function ok(msg) { if (!quiet)
-    console.log(`  ${c('green', '✔')} ${msg}`); }
-function warn(msg) { if (!quiet)
-    console.log(`  ${c('yellow', '⚠')}  ${msg}`); }
-function err(msg) { console.error(`  ${c('red', '✖')} ${msg}`); }
-function dim(msg) { if (!quiet)
-    console.log(`  ${c('gray', msg)}`); }
-function dbg(msg) { if (verbose)
-    console.log(`  ${c('gray', '⊡')} ${c('gray', msg)}`); }
+  quiet = q;
+  verbose = v;
+}
+function log(msg) {
+  if (!quiet) console.log(msg);
+}
+function ok(msg) {
+  if (!quiet) console.log(`  ${c('green', '✔')} ${msg}`);
+}
+function warn(msg) {
+  if (!quiet) console.log(`  ${c('yellow', '⚠')}  ${msg}`);
+}
+function err(msg) {
+  console.error(`  ${c('red', '✖')} ${msg}`);
+}
+function dim(msg) {
+  if (!quiet) console.log(`  ${c('gray', msg)}`);
+}
+function dbg(msg) {
+  if (verbose) console.log(`  ${c('gray', '⊡')} ${c('gray', msg)}`);
+}