@colin4k1024/tsp 2.5.2 → 2.5.4

package/scripts/lib/loop-state-store.js

@@ -0,0 +1,221 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const DEFAULT_TARGET = 'claude';
+
+const TARGET_STATE_DIRS = Object.freeze({
+  claude: ['.claude', 'loops'],
+  codex: ['.codex', 'loops'],
+  opencode: ['.config', 'opencode', 'loops'],
+  cangming: ['.cangming', 'loops'],
+  codewhale: ['.codewhale', 'loops'],
+  codebuddy: ['.codebuddy', 'loops'],
+});
+
+const LEGACY_CLAUDE_DIRS = Object.freeze({
+  goals: ['.claude', 'goals'],
+  triage: ['.claude', 'triage'],
+  heartbeatLastRun: ['.claude', 'heartbeat-last-run.json'],
+});
+
+function readHome() {
+  return process.env.HOME || process.env.USERPROFILE || os.homedir();
+}
+
+function normalizeTarget(target) {
+  return String(target || process.env.TSP_LOOP_TARGET || DEFAULT_TARGET).trim().toLowerCase() || DEFAULT_TARGET;
+}
+
+function projectLocalStateDir(projectRoot) {
+  if (!projectRoot) return null;
+  return path.join(path.resolve(projectRoot), '.tsp', 'loops');
+}
+
+function targetDefaultStateDir(target) {
+  const home = readHome();
+  const parts = TARGET_STATE_DIRS[normalizeTarget(target)] || TARGET_STATE_DIRS[DEFAULT_TARGET];
+  return path.join(home, ...parts);
+}
+
+function getLoopStateDir(options = {}) {
+  if (process.env.TSP_LOOP_STATE_DIR) {
+    return path.resolve(process.env.TSP_LOOP_STATE_DIR);
+  }
+
+  if (options.stateDir) {
+    return path.resolve(options.stateDir);
+  }
+
+  if (options.projectRoot) {
+    return projectLocalStateDir(options.projectRoot);
+  }
+
+  return targetDefaultStateDir(options.target);
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+  return dirPath;
+}
+
+function ensureLoopStateDir(options = {}) {
+  return ensureDir(getLoopStateDir(options));
+}
+
+function getNamespaceDir(namespace, options = {}) {
+  return path.join(getLoopStateDir(options), namespace);
+}
+
+function ensureNamespaceDir(namespace, options = {}) {
+  return ensureDir(getNamespaceDir(namespace, options));
+}
+
+function getGoalPath(goalId, options = {}) {
+  return path.join(getNamespaceDir('goals', options), `${goalId}.json`);
+}
+
+function getTriageInboxPath(options = {}) {
+  return path.join(getNamespaceDir('triage', options), 'inbox.jsonl');
+}
+
+function getHeartbeatPath(loopId = 'default', options = {}) {
+  return path.join(getNamespaceDir('heartbeat', options), `${loopId}.json`);
+}
+
+function getLoopMarkdownStatePath(loopId, options = {}) {
+  return path.join(getNamespaceDir('state', options), `${loopId}.md`);
+}
+
+function writeJson(filePath, value) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+  return filePath;
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function saveGoal(goal, options = {}) {
+  return writeJson(getGoalPath(goal.goalId, options), goal);
+}
+
+function loadGoal(goalId, options = {}) {
+  const filePath = getGoalPath(goalId, options);
+  if (fs.existsSync(filePath)) {
+    return readJson(filePath);
+  }
+
+  const legacyPath = getLegacyGoalPath(goalId);
+  if (!options.disableLegacyLookup && legacyPath && fs.existsSync(legacyPath)) {
+    return readJson(legacyPath);
+  }
+
+  return null;
+}
+
+function listJsonFiles(dirPath) {
+  if (!fs.existsSync(dirPath)) return [];
+  return fs.readdirSync(dirPath)
+    .filter(fileName => fileName.endsWith('.json'))
+    .map(fileName => path.join(dirPath, fileName));
+}
+
+function listGoals(filter, options = {}) {
+  const filePaths = listJsonFiles(getNamespaceDir('goals', options));
+
+  if (!options.disableLegacyLookup) {
+    const legacyDir = getLegacyDir('goals');
+    if (legacyDir && path.resolve(legacyDir) !== path.resolve(getNamespaceDir('goals', options))) {
+      filePaths.push(...listJsonFiles(legacyDir));
+    }
+  }
+
+  const seenGoalIds = new Set();
+  return filePaths
+    .map(filePath => {
+      try {
+        return readJson(filePath);
+      } catch {
+        return null;
+      }
+    })
+    .filter(goal => {
+      if (!goal || !goal.goalId || seenGoalIds.has(goal.goalId)) return false;
+      seenGoalIds.add(goal.goalId);
+      return true;
+    })
+    .filter(goal => !filter || goal.state === filter)
+    .sort((a, b) => new Date(b.updatedAt || 0) - new Date(a.updatedAt || 0));
+}
+
+function appendTriageItem(item, options = {}) {
+  const inboxPath = getTriageInboxPath(options);
+  ensureDir(path.dirname(inboxPath));
+  fs.appendFileSync(inboxPath, `${JSON.stringify(item)}\n`, 'utf8');
+  return inboxPath;
+}
+
+function saveHeartbeat(loopId, value, options = {}) {
+  return writeJson(getHeartbeatPath(loopId, options), value);
+}
+
+function loadHeartbeat(loopId = 'default', options = {}) {
+  const filePath = getHeartbeatPath(loopId, options);
+  if (fs.existsSync(filePath)) {
+    return readJson(filePath);
+  }
+
+  const legacyPath = getLegacyHeartbeatLastRunPath();
+  if (!options.disableLegacyLookup && loopId === 'last-run' && legacyPath && fs.existsSync(legacyPath)) {
+    return readJson(legacyPath);
+  }
+
+  return null;
+}
+
+function saveLoopMarkdownState(loopId, content, options = {}) {
+  const statePath = getLoopMarkdownStatePath(loopId, options);
+  ensureDir(path.dirname(statePath));
+  fs.writeFileSync(statePath, String(content), 'utf8');
+  return statePath;
+}
+
+function getLegacyDir(namespace) {
+  const parts = LEGACY_CLAUDE_DIRS[namespace];
+  if (!parts) return null;
+  return path.join(readHome(), ...parts);
+}
+
+function getLegacyGoalPath(goalId) {
+  const legacyDir = getLegacyDir('goals');
+  return legacyDir ? path.join(legacyDir, `${goalId}.json`) : null;
+}
+
+function getLegacyHeartbeatLastRunPath() {
+  return path.join(readHome(), ...LEGACY_CLAUDE_DIRS.heartbeatLastRun);
+}
+
+module.exports = {
+  TARGET_STATE_DIRS,
+  getLoopStateDir,
+  ensureLoopStateDir,
+  getNamespaceDir,
+  ensureNamespaceDir,
+  getGoalPath,
+  getTriageInboxPath,
+  getHeartbeatPath,
+  getLoopMarkdownStatePath,
+  saveGoal,
+  loadGoal,
+  listGoals,
+  appendTriageItem,
+  saveHeartbeat,
+  loadHeartbeat,
+  saveLoopMarkdownState,
+  targetDefaultStateDir,
+  projectLocalStateDir,
+};

package/scripts/lib/transcript-usage.js

@@ -0,0 +1,193 @@
+'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 totalTokens = Number(raw.total_tokens || 0) || 0;
+
+  // CCometixLine's context-window segment treats active context as prompt-side
+  // tokens: input + cache creation + cache read. The current turn's output is
+  // tracked separately because it becomes prompt-side context on the next turn.
+  const promptSideContextTokens = inputTokens + cacheCreationTokens + cacheReadTokens;
+  const contextTokens = promptSideContextTokens || totalTokens || (inputTokens + outputTokens);
+  if (contextTokens === 0) return null;
+
+  return {
+    inputTokens,
+    outputTokens,
+    cacheCreationTokens,
+    cacheReadTokens,
+    totalTokens,
+    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)));
+  const remainingTokens = Math.max(0, contextLimit - usage.contextTokens);
+  const remainingPct = Math.max(0, Math.min(100, Math.round((remainingTokens / contextLimit) * 100)));
+
+  return {
+    usagePct,
+    contextTokens: usage.contextTokens,
+    contextLimit,
+    remainingTokens,
+    remainingPct,
+    source: 'transcript_usage',
+  };
+}
+
+module.exports = {
+  resolveContextLimit,
+  readTailLines,
+  parseTranscriptUsage,
+  resolveTranscriptMetrics,
+  normalizeUsage,
+  DEFAULT_CONTEXT_LIMIT,
+  EXTENDED_CONTEXT_LIMIT,
+};

package/scripts/test-cangming-install.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CANGMING_HOME = path.join(os.homedir(), '.config', 'cangming');
+const PLUGIN_DIR = path.join(CANGMING_HOME, 'plugins', 'team-skills-platform');
+
+console.log('=== Cangming 安装验证 ===\n');
+
+let passed = 0;
+let failed = 0;
+
+function check(description, condition) {
+  if (condition) {
+    console.log(`✅ ${description}`);
+    passed++;
+  } else {
+    console.log(`❌ ${description}`);
+    failed++;
+  }
+}
+
+console.log('📁 目录结构检查:');
+check('CANGMING_HOME 目录存在', fs.existsSync(CANGMING_HOME));
+check('AGENTS.md 文件存在', fs.existsSync(path.join(CANGMING_HOME, 'AGENTS.md')));
+check('agents 目录存在', fs.existsSync(path.join(CANGMING_HOME, 'agents')));
+check('command 目录存在', fs.existsSync(path.join(CANGMING_HOME, 'command')));
+check('plugins 目录存在', fs.existsSync(path.join(CANGMING_HOME, 'plugins')));
+check('team-skills-platform 插件存在', fs.existsSync(PLUGIN_DIR));
+
+console.log('\n📄 文件内容检查:');
+
+const agentsMdPath = path.join(CANGMING_HOME, 'AGENTS.md');
+if (fs.existsSync(agentsMdPath)) {
+  const content = fs.readFileSync(agentsMdPath, 'utf8');
+  check('AGENTS.md 包含团队技能平台标记', content.includes('<!-- team-skills-platform -->'));
+  check('AGENTS.md 包含角色索引', content.includes('## 可用角色'));
+  check('AGENTS.md 包含命令索引', content.includes('## 核心团队命令'));
+  check('AGENTS.md 包含插件根路径', content.includes('## 插件根路径'));
+}
+
+console.log('\n👥 Agents 检查:');
+const agentsDir = path.join(CANGMING_HOME, 'agents');
+if (fs.existsSync(agentsDir)) {
+  const agentFiles = fs.readdirSync(agentsDir).filter(f => f.endsWith('.md'));
+  check(`agents 目录包含文件 (${agentFiles.length})`, agentFiles.length > 0);
+
+  const roleAgents = ['tech-lead.md', 'product-manager.md', 'architect.md', 'frontend-engineer.md',
+                      'backend-engineer.md', 'qa-engineer.md', 'devops-engineer.md'];
+  for (const agent of roleAgents) {
+    check(`角色 agent ${agent} 存在`, fs.existsSync(path.join(agentsDir, agent)));
+  }
+
+  const specialistAgents = agentFiles.filter(f => f.startsWith('specialist-'));
+  check(`specialist agents 存在 (${specialistAgents.length})`, specialistAgents.length > 0);
+}
+
+console.log('\n📝 Commands 检查:');
+const commandsDir = path.join(CANGMING_HOME, 'command');
+if (fs.existsSync(commandsDir)) {
+  const commandFiles = fs.readdirSync(commandsDir).filter(f => f.endsWith('.md'));
+  check(`commands 目录包含文件 (${commandFiles.length})`, commandFiles.length > 0);
+
+  const coreCommands = ['team-intake.md', 'team-plan.md', 'team-execute.md', 'team-review.md',
+                        'team-release.md', 'handoff.md'];
+  for (const cmd of coreCommands) {
+    check(`核心命令 ${cmd} 存在`, fs.existsSync(path.join(commandsDir, cmd)));
+  }
+}
+
+console.log('\n🎯 Skills 检查:');
+const skillsDir = path.join(PLUGIN_DIR, 'skills');
+if (fs.existsSync(skillsDir)) {
+  const skillDirs = fs.readdirSync(skillsDir, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => d.name);
+  check(`skills 目录包含目录 (${skillDirs.length})`, skillDirs.length > 0);
+}
+
+console.log('\n📜 Rules 检查:');
+const rulesDir = path.join(PLUGIN_DIR, 'rules');
+if (fs.existsSync(rulesDir)) {
+  const ruleItems = fs.readdirSync(rulesDir);
+  check(`rules 目录包含内容 (${ruleItems.length})`, ruleItems.length > 0);
+  check('common 规则目录存在', fs.existsSync(path.join(rulesDir, 'common')));
+}
+
+// 总结
+console.log('\n=== 测试总结 ===');
+console.log(`通过: ${passed}`);
+console.log(`失败: ${failed}`);
+console.log(`总计: ${passed + failed}`);
+
+if (failed === 0) {
+  console.log('\n🎉 所有测试通过！Cangming 安装成功。');
+  console.log('\n下一步:');
+  console.log('1. 启动 Cangming: cangming');
+  console.log('2. 查看可用角色: AGENTS.md 中包含所有角色索引');
+  console.log('3. 执行团队命令: /team-intake, /team-plan 等');
+  process.exit(0);
+} else {
+  console.log('\n⚠️  部分测试失败，请检查安装。');
+  process.exit(1);
+}

package/skills/strategic-compact/SKILL.md

@@ -12,7 +12,7 @@ origin: adapted from ECC
 
 ## 何时激活
 
-- 会话上下文超过 70% 使用率
+- 会话上下文超过 65% 使用率
 - 需要重组上下文以保留关键信息
 - 长会话中需要压缩早期对话
 - 需要按重要性重新组织 specialist 输出
@@ -25,6 +25,7 @@ origin: adapted from ECC
 
 | Trigger | 条件 | 行为 |
 |---------|------|------|
+| `context_65%` | 上下文使用 > 65% | 触发 advisory 压缩建议 |
 | `context_70%` | 上下文使用 > 70% | 触发压缩建议 |
 | `context_85%` | 上下文使用 > 85% | 强制压缩 |
 | `logical_break` | 检测到逻辑断点 | 建议整理 |
@@ -95,11 +96,19 @@ Specialist：输出详细代码审查报告
 系统：保存结论到 memory store
 ```
 
+## Context 计算与 Compact 轮次
+
+- 运行时使用 `scripts/lib/context-window.js` 统一计算上下文压力。
+- 优先消费 CCometixLine-compatible remaining context，例如 `ccometixline.context_window.remaining_percentage`、`ccometixline_context_window.remaining_tokens`、`TSP_CONTEXT_WINDOW_JSON` 或 `CCOMETIXLINE_CONTEXT_FILE`。
+- 如果没有外部 remaining 信号，则退回 Claude `context_window`、transcript JSONL usage、bridge file 和 transcript size fallback。
+- `scripts/hooks/pre-compact.js` 每次 PreCompact 会递增 `.tsp/context/compact-state.json` 的 session / total compact count；`suggest-compact.js` 输出 `compact_count`。
+
 ## 触发阈值
 
 | 使用率 | 紧迫度 | 建议操作 |
 |--------|--------|---------|
-| < 70% | low | 无需操作 |
+| < 65% | low | 无需操作 |
+| 65-70% | advisory | 提醒控制上下文增长 |
 | 70-85% | medium | 建议压缩，可选择性执行 |
 | 85-95% | high | 强烈建议压缩 |
 | > 95% | critical | 必须立即压缩 |