@colin4k1024/tsp 2.5.1 → 2.5.3

package/scripts/lib/install-targets/cangming-home.js

@@ -0,0 +1,143 @@
+const fs = require('fs');
+const path = require('path');
+
+const {
+  createInstallTargetAdapter,
+  createManagedOperation,
+  normalizeRelativePath,
+} = require('./helpers');
+
+const PLUGIN_NAME = require('../team-skills-data.json').plugin.name;
+
+function addOperation(operations, seen, operation) {
+  const key = `${operation.sourceRelativePath}=>${operation.destinationPath}`;
+  if (seen.has(key)) {
+    return;
+  }
+  seen.add(key);
+  operations.push(operation);
+}
+
+function addCopyOperation(operations, seen, moduleId, sourceRelativePath, destinationPath, strategy = 'preserve-relative-path') {
+  addOperation(operations, seen, createManagedOperation({
+    moduleId,
+    sourceRelativePath,
+    destinationPath,
+    strategy,
+  }));
+}
+
+function sourceDir(input, sourceRelativePath) {
+  return path.join(input.repoRoot || '', normalizeRelativePath(sourceRelativePath));
+}
+
+function rootAgentFileName(sourcePath, fileName) {
+  const normalizedSourcePath = normalizeRelativePath(sourcePath);
+  if (normalizedSourcePath === 'agents/specialists' || normalizedSourcePath.startsWith('agents/specialists/')) {
+    return `specialist-${fileName}`;
+  }
+  return fileName;
+}
+
+function addRootAgentOperations(operations, seen, moduleId, sourceRelativePath, input, targetRoot) {
+  const normalizedSourcePath = normalizeRelativePath(sourceRelativePath);
+  if (normalizedSourcePath !== 'agents' && !normalizedSourcePath.startsWith('agents/')) {
+    return;
+  }
+
+  const agentDirs = normalizedSourcePath === 'agents'
+    ? ['roles', 'specialists']
+    : [''];
+
+  for (const agentDir of agentDirs) {
+    const sourcePath = agentDir ? path.join(normalizedSourcePath, agentDir) : normalizedSourcePath;
+    const absoluteSourceDir = sourceDir(input, sourcePath);
+    if (!input.repoRoot || !fs.existsSync(absoluteSourceDir)) {
+      continue;
+    }
+
+    const stat = fs.statSync(absoluteSourceDir);
+    if (stat.isFile() && path.extname(absoluteSourceDir) === '.md') {
+      const fileName = rootAgentFileName(path.dirname(sourcePath), path.basename(sourcePath));
+      addCopyOperation(
+        operations,
+        seen,
+        moduleId,
+        sourcePath,
+        path.join(targetRoot, 'agents', fileName),
+        'flatten-agent-copy'
+      );
+      continue;
+    }
+
+    if (!stat.isDirectory()) {
+      continue;
+    }
+
+    for (const entry of fs.readdirSync(absoluteSourceDir, { withFileTypes: true }).sort((left, right) => (
+      left.name.localeCompare(right.name)
+    ))) {
+      if (entry.isFile() && entry.name.endsWith('.md')) {
+        const fileName = rootAgentFileName(sourcePath, entry.name);
+        addCopyOperation(
+          operations,
+          seen,
+          moduleId,
+          path.join(sourcePath, entry.name),
+          path.join(targetRoot, 'agents', fileName),
+          'flatten-agent-copy'
+        );
+      }
+    }
+  }
+}
+
+function planCangmingOperations(input, adapter) {
+  const targetRoot = adapter.resolveRoot(input);
+  const pluginRoot = path.join(targetRoot, 'plugins', PLUGIN_NAME);
+  const operations = [];
+  const seen = new Set();
+
+  for (const module of Array.isArray(input.modules) ? input.modules : []) {
+    for (const rawSourcePath of Array.isArray(module.paths) ? module.paths : []) {
+      const sourceRelativePath = normalizeRelativePath(rawSourcePath);
+
+      addCopyOperation(
+        operations,
+        seen,
+        module.id,
+        sourceRelativePath,
+        path.join(pluginRoot, sourceRelativePath),
+        'plugin-copy'
+      );
+
+      if (sourceRelativePath === 'commands' || sourceRelativePath.startsWith('commands/')) {
+        const commandSuffix = sourceRelativePath === 'commands'
+          ? ''
+          : sourceRelativePath.slice('commands/'.length);
+        addCopyOperation(
+          operations,
+          seen,
+          module.id,
+          sourceRelativePath,
+          path.join(targetRoot, 'command', commandSuffix),
+          'opencode-command-copy'
+        );
+      }
+
+      addRootAgentOperations(operations, seen, module.id, sourceRelativePath, input, targetRoot);
+    }
+  }
+
+  return operations;
+}
+
+module.exports = createInstallTargetAdapter({
+  id: 'cangming-home',
+  target: 'cangming',
+  kind: 'home',
+  rootSegments: ['.config', 'cangming'],
+  installStatePathSegments: ['ecc-install-state.json'],
+  nativeRootRelativePath: '.cangming',
+  planOperations: planCangmingOperations,
+});

package/scripts/lib/install-targets/codewhale-home.js

@@ -0,0 +1,187 @@
+const fs = require('fs');
+const path = require('path');
+
+const {
+  createInstallTargetAdapter,
+  createManagedOperation,
+  normalizeRelativePath,
+} = require('./helpers');
+
+const PLUGIN_NAME = require('../team-skills-data.json').plugin.name;
+
+function addOperation(operations, seen, operation) {
+  const key = `${operation.sourceRelativePath}=>${operation.destinationPath}`;
+  if (seen.has(key)) {
+    return;
+  }
+  seen.add(key);
+  operations.push(operation);
+}
+
+function addCopyOperation(operations, seen, moduleId, sourceRelativePath, destinationPath, strategy = 'preserve-relative-path') {
+  addOperation(operations, seen, createManagedOperation({
+    moduleId,
+    sourceRelativePath,
+    destinationPath,
+    strategy,
+  }));
+}
+
+function sourceDir(input, sourceRelativePath) {
+  return path.join(input.repoRoot || '', normalizeRelativePath(sourceRelativePath));
+}
+
+function addAgentOperations(operations, seen, moduleId, sourceRelativePath, input, targetRoot) {
+  const normalizedSourcePath = normalizeRelativePath(sourceRelativePath);
+  if (normalizedSourcePath !== 'agents' && !normalizedSourcePath.startsWith('agents/')) {
+    return;
+  }
+
+  const agentDirs = normalizedSourcePath === 'agents'
+    ? ['roles', 'specialists']
+    : [''];
+
+  for (const agentDir of agentDirs) {
+    const sourcePath = agentDir ? path.join(normalizedSourcePath, agentDir) : normalizedSourcePath;
+    const absoluteSourceDir = sourceDir(input, sourcePath);
+    if (!input.repoRoot || !fs.existsSync(absoluteSourceDir)) {
+      continue;
+    }
+
+    const stat = fs.statSync(absoluteSourceDir);
+    if (stat.isFile() && path.extname(absoluteSourceDir) === '.md') {
+      const fileName = path.basename(sourcePath);
+      addCopyOperation(
+        operations, seen, moduleId, sourcePath,
+        path.join(targetRoot, 'agents', fileName),
+        'flatten-agent-copy'
+      );
+      continue;
+    }
+
+    if (!stat.isDirectory()) {
+      continue;
+    }
+
+    for (const entry of fs.readdirSync(absoluteSourceDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      if (entry.isFile() && entry.name.endsWith('.md')) {
+        const prefix = agentDir === 'specialists' ? 'specialist-' : '';
+        addCopyOperation(
+          operations, seen, moduleId,
+          path.join(sourcePath, entry.name),
+          path.join(targetRoot, 'agents', `${prefix}${entry.name}`),
+          'flatten-agent-copy'
+        );
+      }
+    }
+  }
+}
+
+function addRuleOperations(operations, seen, moduleId, sourceRelativePath, input, targetRoot) {
+  const normalizedSourcePath = normalizeRelativePath(sourceRelativePath);
+  if (normalizedSourcePath !== 'rules' && !normalizedSourcePath.startsWith('rules/')) {
+    return;
+  }
+
+  const absoluteSourceDir = sourceDir(input, normalizedSourcePath);
+  if (!input.repoRoot || !fs.existsSync(absoluteSourceDir) || !fs.statSync(absoluteSourceDir).isDirectory()) {
+    return;
+  }
+
+  const entries = fs.readdirSync(absoluteSourceDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    const entryPath = path.join(absoluteSourceDir, entry.name);
+    if (entry.isDirectory()) {
+      const subEntries = fs.readdirSync(entryPath, { withFileTypes: true });
+      for (const sub of subEntries) {
+        if (sub.isFile() && sub.name.endsWith('.md')) {
+          addCopyOperation(
+            operations, seen, moduleId,
+            path.join(normalizedSourcePath, entry.name, sub.name),
+            path.join(targetRoot, 'rules', entry.name, sub.name),
+            'rule-copy'
+          );
+        }
+      }
+    } else if (entry.isFile() && entry.name.endsWith('.md')) {
+      addCopyOperation(
+        operations, seen, moduleId,
+        path.join(normalizedSourcePath, entry.name),
+        path.join(targetRoot, 'rules', entry.name),
+        'rule-copy'
+      );
+    }
+  }
+}
+
+function planCodeWhaleOperations(input, adapter) {
+  const targetRoot = adapter.resolveRoot(input);
+  const operations = [];
+  const seen = new Set();
+
+  for (const module of Array.isArray(input.modules) ? input.modules : []) {
+    for (const rawSourcePath of Array.isArray(module.paths) ? module.paths : []) {
+      const sourceRelativePath = normalizeRelativePath(rawSourcePath);
+
+      // Skills: preserve directory structure
+      if (sourceRelativePath === 'skills' || sourceRelativePath.startsWith('skills/')) {
+        addCopyOperation(
+          operations, seen, module.id, sourceRelativePath,
+          path.join(targetRoot, 'skills', sourceRelativePath.replace(/^skills\/?/, '')),
+          'skill-copy'
+        );
+      }
+
+      // Commands: flatten to commands/
+      if (sourceRelativePath === 'commands' || sourceRelativePath.startsWith('commands/')) {
+        const commandSuffix = sourceRelativePath === 'commands'
+          ? ''
+          : sourceRelativePath.slice('commands/'.length);
+        addCopyOperation(
+          operations, seen, module.id, sourceRelativePath,
+          path.join(targetRoot, 'commands', commandSuffix),
+          'command-copy'
+        );
+      }
+
+      // Agents: flatten roles + specialists
+      addAgentOperations(operations, seen, module.id, sourceRelativePath, input, targetRoot);
+
+      // Rules: preserve namespace/file structure
+      addRuleOperations(operations, seen, module.id, sourceRelativePath, input, targetRoot);
+
+      // Contexts: direct copy
+      if (sourceRelativePath === 'contexts' || sourceRelativePath.startsWith('contexts/')) {
+        const contextSuffix = sourceRelativePath === 'contexts'
+          ? ''
+          : sourceRelativePath.slice('contexts/'.length);
+        addCopyOperation(
+          operations, seen, module.id, sourceRelativePath,
+          path.join(targetRoot, 'contexts', contextSuffix),
+          'context-copy'
+        );
+      }
+
+      // Hooks: copy hooks directory for reference, config.toml injection handled by post-install
+      if (sourceRelativePath === 'hooks' || sourceRelativePath.startsWith('hooks/')) {
+        addCopyOperation(
+          operations, seen, module.id, sourceRelativePath,
+          path.join(targetRoot, 'hooks', sourceRelativePath.replace(/^hooks\/?/, '')),
+          'hook-copy'
+        );
+      }
+    }
+  }
+
+  return operations;
+}
+
+module.exports = createInstallTargetAdapter({
+  id: 'codewhale-home',
+  target: 'codewhale',
+  kind: 'home',
+  rootSegments: ['.codewhale'],
+  installStatePathSegments: ['ecc-install-state.json'],
+  nativeRootRelativePath: '.codewhale',
+  planOperations: planCodeWhaleOperations,
+});

package/scripts/lib/install-targets/registry.js

@@ -1,15 +1,17 @@
 const antigravityProject = require('./antigravity-project');
 const augmentProject = require('./augment-project');
+const cangmingHome = require('./cangming-home');
 const claudeHome = require('./claude-home');
 const codebuddyProject = require('./codebuddy-project');
 const codexHome = require('./codex-home');
+const codewhaleHome = require('./codewhale-home');
 const copilotHome = require('./copilot-home');
 const cursorProject = require('./cursor-project');
 const geminiProject = require('./gemini-project');
 const opencodeHome = require('./opencode-home');
 const windsurfProject = require('./windsurf-project');
 
-const PUBLIC_INSTALL_TARGETS = Object.freeze(['claude', 'codex', 'opencode']);
+const PUBLIC_INSTALL_TARGETS = Object.freeze(['claude', 'codex', 'opencode', 'cangming', 'codewhale']);
 const TARGET_ALIASES = Object.freeze({
   'claude-code': 'claude',
   claudecode: 'claude',
@@ -22,6 +24,8 @@ const ADAPTERS = Object.freeze([
   codexHome,
   geminiProject,
   opencodeHome,
+  cangmingHome,
+  codewhaleHome,
   codebuddyProject,
   copilotHome,
   windsurfProject,

package/scripts/lib/transcript-usage.js

@@ -0,0 +1,183 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_CONTEXT_LIMIT = 200000;
+const EXTENDED_CONTEXT_LIMIT = 1000000;
+const DEFAULT_TAIL_BYTES = 65536;
+const EXPANDED_TAIL_BYTES = 262144;
+
+function resolveContextLimit(modelId) {
+  const envLimit = Number(process.env.CLAUDE_CONTEXT_LIMIT);
+  if (Number.isFinite(envLimit) && envLimit > 0) return envLimit;
+
+  if (typeof modelId === 'string' && /\[1[mM]\]/i.test(modelId)) {
+    return EXTENDED_CONTEXT_LIMIT;
+  }
+
+  return DEFAULT_CONTEXT_LIMIT;
+}
+
+function readTailLines(filePath, tailBytes = DEFAULT_TAIL_BYTES) {
+  let fd;
+  try {
+    const stat = fs.statSync(filePath);
+    if (stat.size === 0) return [];
+
+    const readSize = Math.min(tailBytes, stat.size);
+    const buffer = Buffer.alloc(readSize);
+    fd = fs.openSync(filePath, 'r');
+    fs.readSync(fd, buffer, 0, readSize, stat.size - readSize);
+    fs.closeSync(fd);
+    fd = null;
+
+    const text = buffer.toString('utf8');
+    const lines = text.split('\n');
+
+    // Drop the first line if we started mid-file (likely partial)
+    if (stat.size > readSize && lines.length > 0) {
+      lines.shift();
+    }
+
+    return lines.filter(line => line.trim().length > 0);
+  } catch (_) {
+    if (fd != null) try { fs.closeSync(fd); } catch (__) { /* ignore */ }
+    return [];
+  }
+}
+
+function normalizeUsage(raw) {
+  if (!raw || typeof raw !== 'object') return null;
+
+  const inputTokens = Number(raw.input_tokens || raw.prompt_tokens || 0) || 0;
+  const outputTokens = Number(raw.output_tokens || raw.completion_tokens || 0) || 0;
+  const cacheCreationTokens = Number(raw.cache_creation_input_tokens || raw.cache_creation_prompt_tokens || 0) || 0;
+  const cacheReadTokens = Number(raw.cache_read_input_tokens || raw.cache_read_prompt_tokens || raw.cached_tokens || 0) || 0;
+
+  const contextTokens = inputTokens + outputTokens + cacheCreationTokens + cacheReadTokens;
+  if (contextTokens === 0) return null;
+
+  return {
+    inputTokens,
+    outputTokens,
+    cacheCreationTokens,
+    cacheReadTokens,
+    contextTokens,
+  };
+}
+
+function parseTranscriptUsage(transcriptPath) {
+  if (!transcriptPath || typeof transcriptPath !== 'string') return null;
+  if (!fs.existsSync(transcriptPath)) return null;
+
+  let lines = readTailLines(transcriptPath, DEFAULT_TAIL_BYTES);
+
+  // Scan from bottom up for the last assistant message with usage
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (!line) continue;
+
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch (_) {
+      continue;
+    }
+
+    // Handle summary entries — they indicate compaction happened
+    if (entry.type === 'summary' && entry.leafUuid) {
+      const projectDir = path.dirname(transcriptPath);
+      const usage = findUsageByLeafUuid(entry.leafUuid, projectDir);
+      if (usage) return usage;
+      continue;
+    }
+
+    if (entry.type !== 'assistant') continue;
+    if (!entry.message || !entry.message.usage) continue;
+
+    return normalizeUsage(entry.message.usage);
+  }
+
+  // If not found in default tail, try expanded read
+  if (lines.length > 0) {
+    lines = readTailLines(transcriptPath, EXPANDED_TAIL_BYTES);
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i].trim();
+      if (!line) continue;
+
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch (_) {
+        continue;
+      }
+
+      if (entry.type !== 'assistant') continue;
+      if (!entry.message || !entry.message.usage) continue;
+
+      return normalizeUsage(entry.message.usage);
+    }
+  }
+
+  return null;
+}
+
+function findUsageByLeafUuid(leafUuid, projectDir) {
+  if (!projectDir || !fs.existsSync(projectDir)) return null;
+
+  let sessionFiles;
+  try {
+    sessionFiles = fs.readdirSync(projectDir)
+      .filter(f => f.endsWith('.jsonl'))
+      .map(f => path.join(projectDir, f));
+  } catch (_) {
+    return null;
+  }
+
+  for (const filePath of sessionFiles) {
+    const lines = readTailLines(filePath, EXPANDED_TAIL_BYTES);
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i].trim();
+      if (!line) continue;
+
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch (_) {
+        continue;
+      }
+
+      if (entry.uuid === leafUuid && entry.type === 'assistant' && entry.message?.usage) {
+        return normalizeUsage(entry.message.usage);
+      }
+    }
+  }
+
+  return null;
+}
+
+function resolveTranscriptMetrics(transcriptPath, modelId) {
+  const usage = parseTranscriptUsage(transcriptPath);
+  if (!usage) return null;
+
+  const contextLimit = resolveContextLimit(modelId);
+  const usagePct = Math.max(0, Math.min(100, Math.round((usage.contextTokens / contextLimit) * 100)));
+
+  return {
+    usagePct,
+    contextTokens: usage.contextTokens,
+    contextLimit,
+    source: 'transcript_usage',
+  };
+}
+
+module.exports = {
+  resolveContextLimit,
+  readTailLines,
+  parseTranscriptUsage,
+  resolveTranscriptMetrics,
+  normalizeUsage,
+  DEFAULT_CONTEXT_LIMIT,
+  EXTENDED_CONTEXT_LIMIT,
+};

package/scripts/lib/wave-cost-advisor.js

@@ -0,0 +1,155 @@
+'use strict';
+
+/**
+ * wave-cost-advisor.js
+ *
+ * Budget-aware wave scheduling for Loop Engineering.
+ * Calculates optimal parallelism based on remaining budget, estimated costs,
+ * and worker availability before launching a wave.
+ *
+ * Integrates with wave-execution skill and the workflow executor.
+ */
+
+const DEFAULT_COST_PER_WORKER = 0.50; // USD per worker iteration (conservative estimate)
+const DEFAULT_MAX_PARALLEL = 4;
+const DEFAULT_BUDGET = 10.0; // USD
+
+function createCostAdvisor(options = {}) {
+  const totalBudget = options.totalBudget || DEFAULT_BUDGET;
+  let spent = options.spent || 0;
+  const maxParallel = options.maxParallel || DEFAULT_MAX_PARALLEL;
+  const costPerWorker = options.costPerWorker || DEFAULT_COST_PER_WORKER;
+
+  return {
+    get remaining() { return totalBudget - spent; },
+    get spent() { return spent; },
+    get totalBudget() { return totalBudget; },
+
+    recordSpend(amount) {
+      spent += amount;
+    },
+
+    adviseBatchSize(taskCount, options = {}) {
+      const estimatedIterations = options.estimatedIterations || 1;
+      const taskCost = options.costPerTask || costPerWorker;
+      const maxWorkers = Math.min(taskCount, maxParallel);
+
+      if (spent >= totalBudget) {
+        return {
+          recommended: 0,
+          reason: 'budget_exhausted',
+          remaining: 0,
+          canAfford: 0,
+        };
+      }
+
+      const remaining = totalBudget - spent;
+      const costPerBatch = maxWorkers * taskCost * estimatedIterations;
+
+      if (costPerBatch <= remaining) {
+        return {
+          recommended: maxWorkers,
+          reason: 'within_budget',
+          remaining,
+          estimatedCost: costPerBatch,
+          canAfford: maxWorkers,
+        };
+      }
+
+      // Reduce parallelism to fit budget
+      const affordableWorkers = Math.max(1, Math.floor(remaining / (taskCost * estimatedIterations)));
+      const actualWorkers = Math.min(affordableWorkers, taskCount);
+
+      return {
+        recommended: actualWorkers,
+        reason: 'budget_constrained',
+        remaining,
+        estimatedCost: actualWorkers * taskCost * estimatedIterations,
+        canAfford: affordableWorkers,
+        requestedButDenied: maxWorkers - actualWorkers,
+      };
+    },
+
+    adviseWavePlan(waves, options = {}) {
+      const taskCost = options.costPerTask || costPerWorker;
+      const plan = [];
+      let projectedSpend = spent;
+
+      for (let i = 0; i < waves.length; i++) {
+        const wave = waves[i];
+        const taskCount = Array.isArray(wave) ? wave.length : wave.taskCount || 1;
+        const remaining = totalBudget - projectedSpend;
+
+        if (remaining <= 0) {
+          plan.push({
+            waveIndex: i,
+            status: 'deferred',
+            reason: 'budget_exhausted',
+            tasks: taskCount,
+            parallelism: 0,
+          });
+          continue;
+        }
+
+        const maxForWave = Math.min(taskCount, maxParallel);
+        const waveCost = maxForWave * taskCost;
+
+        if (waveCost <= remaining) {
+          plan.push({
+            waveIndex: i,
+            status: 'full',
+            tasks: taskCount,
+            parallelism: maxForWave,
+            estimatedCost: waveCost,
+          });
+          projectedSpend += waveCost;
+        } else {
+          const affordable = Math.max(1, Math.floor(remaining / taskCost));
+          const actual = Math.min(affordable, taskCount);
+          plan.push({
+            waveIndex: i,
+            status: 'reduced',
+            tasks: taskCount,
+            parallelism: actual,
+            estimatedCost: actual * taskCost,
+            note: `Reduced from ${maxForWave} to ${actual} workers due to budget`,
+          });
+          projectedSpend += actual * taskCost;
+        }
+      }
+
+      return {
+        plan,
+        projectedTotalCost: projectedSpend,
+        remainingAfterPlan: totalBudget - projectedSpend,
+        budgetUtilization: projectedSpend / totalBudget,
+      };
+    },
+
+    shouldPause() {
+      return spent >= totalBudget;
+    },
+
+    formatSummary() {
+      const pct = ((spent / totalBudget) * 100).toFixed(1);
+      return `Budget: $${spent.toFixed(2)} / $${totalBudget.toFixed(2)} (${pct}% used), $${(totalBudget - spent).toFixed(2)} remaining`;
+    },
+  };
+}
+
+function estimateGoalCost(goal, averageCostPerIteration) {
+  const remainingIterations = (goal.budget?.maxIterations || 15) - (goal.currentIteration || 0);
+  const avgCost = averageCostPerIteration || DEFAULT_COST_PER_WORKER;
+  return {
+    bestCase: avgCost,
+    expectedCase: avgCost * Math.min(3, remainingIterations),
+    worstCase: avgCost * remainingIterations,
+  };
+}
+
+module.exports = {
+  DEFAULT_COST_PER_WORKER,
+  DEFAULT_MAX_PARALLEL,
+  createCostAdvisor,
+  estimateGoalCost,
+};