code-yangzz 1.0.0

package/hooks/stop-completion-guard.mjs

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+/**
+ * Optional Stop-hook guard against premature "done" claims (weak heuristic).
+ *
+ * OFF by default (zero noise). Enable:
+ *   META_KIM_STOP_COMPLETION_GUARD=hint   → stderr reminder only; stop proceeds
+ *   META_KIM_STOP_COMPLETION_GUARD=block  → JSON { decision, reason } to continue until governance cues appear
+ *
+ * Always exits 0 when stop_hook_active is true (avoid Stop hook loops).
+ * See https://code.claude.com/docs/en/hooks-guide — Stop hook input includes stop_hook_active and may include transcript_path.
+ */
+
+import { createReadStream } from "node:fs";
+import { readFile } from "node:fs/promises";
+import process from "node:process";
+import readline from "node:readline";
+
+const COMPLETION_RE =
+  /(?:任务已全部完成|全部完成|已经完成|可以发布了|实施完成|工作已完成|圆满完成|大功告成|已全部搞定|done\.?\s*All tasks|implementation complete|fully complete|ready to (?:ship|publish)|all set(?:\s|$)|mission accomplished)/i;
+
+const EVIDENCE_RE =
+  /verificationPacket|summaryClosed|publicDisplay|validate:run|closeFindings|verified_closed|summaryPacket|npm run validate/;
+
+async function readStdinJson() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (!raw) {
+    return {};
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+/** Last ~16k chars of assistant-visible text from a JSONL transcript (best-effort). */
+async function tailAssistantText(transcriptPath, maxBytes = 16_384) {
+  const stat = await readFile(transcriptPath).catch(() => null);
+  if (!stat) {
+    return "";
+  }
+  const full = stat.toString("utf8");
+  const lines = full.split("\n").filter(Boolean);
+  const texts = [];
+  for (const line of lines) {
+    let row;
+    try {
+      row = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const msg = row.message ?? row;
+    const role = msg.role ?? row.role;
+    if (role !== "assistant") {
+      continue;
+    }
+    const c = msg.content;
+    if (typeof c === "string") {
+      texts.push(c);
+    } else if (Array.isArray(c)) {
+      for (const part of c) {
+        if (part?.type === "text" && typeof part.text === "string") {
+          texts.push(part.text);
+        }
+      }
+    }
+  }
+  const joined = texts.join("\n");
+  if (joined.length <= maxBytes) {
+    return joined;
+  }
+  return joined.slice(-maxBytes);
+}
+
+/** Streaming tail when file is huge: read last lines and grep assistant-ish JSON (fallback). */
+async function tailTranscriptFallback(transcriptPath) {
+  return new Promise((resolve) => {
+    const parts = [];
+    const rl = readline.createInterface({
+      input: createReadStream(transcriptPath, { encoding: "utf8" }),
+      crlfDelay: Infinity,
+    });
+    const buf = [];
+    const maxLines = 400;
+    rl.on("line", (line) => {
+      buf.push(line);
+      if (buf.length > maxLines) {
+        buf.shift();
+      }
+    });
+    rl.on("close", () => {
+      for (const line of buf) {
+        if (line.includes('"role":"assistant"') || line.includes('"role": "assistant"')) {
+          parts.push(line);
+        }
+      }
+      resolve(parts.join("\n").slice(-16_384));
+    });
+    rl.on("error", () => resolve(""));
+  });
+}
+
+async function main() {
+  const input = await readStdinJson();
+
+  if (input.stop_hook_active === true) {
+    process.exit(0);
+  }
+
+  const mode = (process.env.META_KIM_STOP_COMPLETION_GUARD || "").trim().toLowerCase();
+  if (!mode || mode === "0" || mode === "off" || mode === "false") {
+    process.exit(0);
+  }
+
+  const transcriptPath = input.transcript_path || input.transcriptPath;
+  let sample = "";
+  if (typeof transcriptPath === "string" && transcriptPath.length > 0) {
+    try {
+      sample = await tailAssistantText(transcriptPath);
+      if (!sample) {
+        sample = await tailTranscriptFallback(transcriptPath);
+      }
+    } catch {
+      sample = "";
+    }
+  }
+
+  if (!sample || sample.length < 20) {
+    process.exit(0);
+  }
+
+  const claimsDone = COMPLETION_RE.test(sample);
+  const hasEvidence = EVIDENCE_RE.test(sample);
+  if (!claimsDone || hasEvidence) {
+    process.exit(0);
+  }
+
+  const reason =
+    "[Fusion] You claimed completion but the last assistant text did not reference verification/summary/validate:run. " +
+    "If this was a governed complex run: produce or update the run artifact, close findings, and align summaryPacket with contracts/workflow-contract.json publicDisplay gates.";
+
+  if (mode === "block") {
+    process.stdout.write(JSON.stringify({ decision: "block", reason }));
+    process.exit(0);
+  }
+
+  if (mode === "hint") {
+    process.stderr.write(`${reason}\n`);
+    process.exit(0);
+  }
+
+  process.exit(0);
+}
+
+main().catch(() => process.exit(0));

package/hooks/stop-console-log-audit.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+/**
+ * Stop hook: audit all modified files for console.log before session ends
+ * Scans git diff for console.log statements
+ */
+
+import { execSync } from "node:child_process";
+
+try {
+  const diff = execSync("git diff --name-only HEAD", {
+    encoding: "utf8",
+    timeout: 5000,
+    stdio: ["pipe", "pipe", "ignore"],
+  }).trim();
+
+  if (!diff) process.exit(0);
+
+  const files = diff
+    .split("\n")
+    .filter((f) => f.match(/\.(js|ts|jsx|tsx|mjs|cjs)$/));
+
+  const violations = [];
+
+  for (const file of files) {
+    try {
+      const content = require("node:fs").readFileSync(file, "utf8");
+      const matches = content.match(/console\.(log|debug|info)\(/g);
+      if (matches) {
+        violations.push(`${file}: ${matches.length} console.log(s)`);
+      }
+    } catch {
+      // file deleted or not readable
+    }
+  }
+
+  if (violations.length > 0) {
+    process.stderr.write(
+      `[audit] console.log found in modified files:\n${violations.join("\n")}\n`
+    );
+  }
+} catch {
+  // git not available or not a repo
+}

package/hooks/subagent-context.mjs

@@ -0,0 +1,27 @@
+import process from "node:process";
+
+await readJsonFromStdin();
+
+const additionalContext = [
+  "Fusion subagent rule set:",
+  "- Optional local research note: docs/meta.md (may be absent in the public repository)",
+  "- Canonical Claude agent source: .claude/agents/*.md",
+  "- After editing agents or skills, run npm run sync:runtimes and npm run validate",
+  "- Prefer the smallest agent boundary that can solve the task cleanly",
+  "- Do not fork runtime-specific instructions unless the target runtime genuinely requires it",
+].join("\n");
+
+process.stdout.write(
+  JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "SubagentStart",
+      additionalContext,
+    },
+  })
+);
+
+async function readJsonFromStdin() {
+  for await (const _chunk of process.stdin) {
+    // The hook only needs to consume stdin so Claude Code can continue.
+  }
+}

package/hooks/user-prompt-submit.js

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+/**
+ * 提示词自动优化Hook - 跨平台版本 (Node.js)
+ *
+ * 支持 Windows/Mac/Linux，无需额外依赖
+ *
+ * 工作流程：
+ * 1. 用户输入提示词
+ * 2. Hook优化
+ * 3. 返回优化后的提示词给Claude
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// 跨平台临时目录
+const LOG_FILE = path.join(os.tmpdir(), 'hook-prompt-optimizer.log');
+
+/**
+ * 记录日志
+ */
+function log(message) {
+    const timestamp = new Date().toISOString();
+    const logEntry = `[${timestamp}] ${message}\n`;
+    try {
+        fs.appendFileSync(LOG_FILE, logEntry);
+    } catch (e) {
+        // 忽略日志错误
+    }
+}
+
+/**
+ * 读取优化提示词模板
+ */
+function readOptimizerTemplate() {
+    // 获取脚本目录并找到模板
+    const scriptDir = __dirname;
+    const claudeDir = path.dirname(scriptDir);
+    const templatePath = path.join(claudeDir, 'prompt-optimizer-meta.md');
+
+    // 备选：检查用户主目录
+    const homeTemplatePath = path.join(os.homedir(), '.claude', 'prompt-optimizer-meta.md');
+
+    if (fs.existsSync(templatePath)) {
+        return fs.readFileSync(templatePath, 'utf8');
+    } else if (fs.existsSync(homeTemplatePath)) {
+        log(`模板文件未在 ${templatePath} 找到，使用主目录版本`);
+        return fs.readFileSync(homeTemplatePath, 'utf8');
+    } else {
+        log(`错误：模板文件未找到：${templatePath} 或 ${homeTemplatePath}`);
+        return null;
+    }
+}
+
+/**
+ * 检查输入是否应该被过滤（不优化）
+ * ⚠️ 注意：此函数内不能写日志！否则会被过滤的输入也会产生日志输出
+ *
+ * @returns {boolean} true表示应该过滤（跳过优化），false表示需要优化
+ */
+function shouldFilter(input) {
+    const trimmed = input.trim();
+
+    // Claude Code 内置命令和Skill命令 - 不应被优化
+    // 匹配: /help, /commit, /review-pr, /skill-name:sub-command 等
+    if (trimmed.startsWith('/')) {
+        return true;
+    }
+
+    // Claude Code 内部系统消息 - 精确匹配已知标签，避免误杀用户的 HTML/JSX 输入
+    const systemTagPattern = /^<(task-notification|system-reminder|tool-result|tool-use|agent-response|claude-internal)[\s>]/;
+    if (systemTagPattern.test(trimmed)) {
+        return true;
+    }
+
+    // 简单交互式回复 - 不需要优化
+    const simpleResponses = [
+        '好的', '是的', '继续', '谢谢', 'ok', 'OK', 'yes', 'YES',
+        'no', 'NO', '确认', '取消', '好', '行', '可以', '不', '嗯',
+        'y', 'n', 'Y', 'N'
+    ];
+
+    // 精确匹配简单回复
+    if (simpleResponses.includes(trimmed)) {
+        return true;
+    }
+
+    // 太短（< 10字符）
+    if (trimmed.length < 10) {
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * 构建优化请求（JSON格式，符合Claude Code Hook API）
+ */
+function buildOptimizationRequest(template, userInput) {
+    // 强制指令放在最前面，优先级最高
+    const forceInstruction = `<MANDATORY_FORMAT_INSTRUCTION>
+【回复格式说明】
+
+你的回复必须严格按以下顺序输出，不得跳过任何部分：
+
+1. 第一行必须是：📝 **原始输入**：${userInput}
+
+2. 然后是：
+🔄 **优化后的理解**：
+- **Context（上下文）**：[推断的场景、身份、目标]
+- **Task（任务）**：[明确的动作 + 要求]
+- **Format（格式）**：[期望的输出形式]
+
+3. 然后是：
+✅ **优化后的完整提示词**：
+[优化后的结构化提示词]
+
+4. 最后是分隔线 --- 后执行任务内容
+
+请在回复开头先展示对用户输入的理解（原始输入 + 优化后的结构化版本），然后再执行任务。这样用户可以看到提示词是如何被优化的。
+</MANDATORY_FORMAT_INSTRUCTION>
+
+---
+
+${template}
+
+---
+
+## 用户原始输入
+
+${userInput}`;
+
+    return {
+        hookSpecificOutput: {
+            hookEventName: "UserPromptSubmit",
+            additionalContext: forceInstruction
+        }
+    };
+}
+
+/**
+ * 解析 Claude Code Hook API 的 JSON 输入
+ * ⚠️ 注意：此函数在shouldFilter之前调用，不能写日志！
+ *
+ * 支持多种输入格式：
+ * 1. { prompt: "用户输入" } - 旧格式
+ * 2. { messages: [{role: "user", content: "用户输入"}] } - 新格式
+ * 3. { session_id: "...", prompt: "用户输入" } - 带session的格式
+ */
+function parseHookInput(rawInput) {
+    try {
+        const parsed = JSON.parse(rawInput);
+
+        // 检查是否有 prompt 字段（最常见的格式）
+        if (parsed.prompt) {
+            return parsed.prompt;
+        }
+
+        // 检查是否有 messages 数组（新格式）
+        if (parsed.messages && Array.isArray(parsed.messages) && parsed.messages.length > 0) {
+            // 获取最后一条用户消息
+            const lastMessage = parsed.messages[parsed.messages.length - 1];
+            if (lastMessage.role === 'user' && lastMessage.content) {
+                return lastMessage.content;
+            }
+        }
+
+        // 如果都没有，返回原始输入
+        return rawInput;
+    } catch (e) {
+        // 如果不是JSON，返回原始输入（可能是纯文本）
+        return rawInput;
+    }
+}
+
+/**
+ * 主函数
+ */
+async function main() {
+    // 从stdin读取输入
+    let rawInput = '';
+
+    // 检查是否通过参数运行
+    if (process.argv.length > 2) {
+        rawInput = process.argv.slice(2).join(' ');
+    } else {
+        // 从stdin读取
+        rawInput = fs.readFileSync(0, 'utf8');
+    }
+
+    rawInput = rawInput.trim();
+
+    // 解析输入，提取实际的用户消息
+    const userInput = parseHookInput(rawInput);
+
+    // 【关键】立即检查是否需要过滤，如果需要则直接退出，不写任何日志
+    if (shouldFilter(userInput)) {
+        process.stdout.write(JSON.stringify({}));
+        return;
+    }
+
+    // 只有通过过滤的输入才会执行到这里，开始写日志
+    log('========================================');
+    log('Hook执行开始');
+    log(`原始输入: ${rawInput.substring(0, 100)}...`);
+    log(`原始输入长度: ${rawInput.length}`);
+    log(`用户输入: ${userInput.substring(0, 100)}...`);
+    log(`输入长度: ${userInput.length}`);
+    log('通过过滤，开始优化...');
+
+    // 读取模板
+    const template = readOptimizerTemplate();
+    if (!template) {
+        log('模板未找到，返回空响应');
+        process.stdout.write(JSON.stringify({}));
+        return;
+    }
+
+    // 构建并输出优化请求
+    const optimizationRequest = buildOptimizationRequest(template, userInput);
+
+    log('优化请求已构建，输出JSON...');
+    log(`JSON长度: ${JSON.stringify(optimizationRequest).length}`);
+    process.stdout.write(JSON.stringify(optimizationRequest));
+}
+
+// 运行
+main().catch(err => {
+    // 出错时返回空响应
+    log(`错误: ${err.message}`);
+    process.stdout.write(JSON.stringify({}));
+});

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "code-yangzz",
+  "version": "1.0.0",
+  "description": "Claude Code / Codex CLI 四层增强系统：输入优化 + 治理框架 + 多Agent编排 + 专业知识库 | by yangzz",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "codex",
+    "cli",
+    "ai",
+    "agent",
+    "governance",
+    "prompt-engineering"
+  ],
+  "author": "yangzz",
+  "license": "MIT",
+  "bin": {
+    "code-yangzz": "bin/install.js"
+  },
+  "files": [
+    "bin/",
+    "config/",
+    "hooks/",
+    "agents/",
+    "skills/",
+    "prompt-optimizer/",
+    "LICENSE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^7.10.1"
+  }
+}

package/prompt-optimizer/prompt-optimizer-meta.md

@@ -0,0 +1,159 @@
+# 提示词优化元提示词
+
+你是一个提示词优化专家，精通谷歌提示词工程指南和5任务元提示词方法论。
+
+## 你的任务
+
+用户会给你一段需求描述。你的任务是把它优化成符合最佳实践的专业提示词。
+
+## 优化原则（基于5任务元提示词）
+
+### 【任务一：构建地基】
+
+1. **应用CTF公式**：
+   - Context（上下文）：从用户输入和当前项目上下文推断身份、受众、目标
+   - Task（任务）：使用强动词（分析、拆解、重写、优化）+ 量化要求
+   - Format（格式）：明确输出结构（Markdown、JSON、列表、代码）
+
+2. **结构化输入**：
+   - 使用分隔符（###, ---）或XML标签（<context>, <data>）
+   - 区分指令与内容
+
+3. **肯定性指令**：
+   - 使用"请使用XXX"而不是"不要使用XXX"
+   - 避免粉色大象效应
+
+### 【任务二：激活推理】
+
+4. **策略选择**：
+   - 简单任务 → 直接问（Zero-Shot）
+   - 需要特定格式/风格 → 给1-3个范例（Few-Shot）
+   - 逻辑/数学题 → 加"让我们一步步思考"（CoT）
+   - 复杂决策 → 让AI模拟多个专家角度（ToT）
+
+5. **自我修正**：
+   - 复杂任务加入Review环节
+   - "先生成草稿，再列出3个缺点，最后根据缺点生成修正版"
+
+### 【任务三：掌控输出】
+
+6. **明确输出格式**：
+   - 提供具体的Schema或示例
+   - 指定验收标准
+
+7. **边界条件**：
+   - 添加异常处理要求
+   - 说明特殊情况的处理方式
+
+## 输出格式（重要！）
+
+你必须按照以下格式输出优化结果：
+
+```markdown
+📝 **原始输入**：[用户的原话]
+
+🔄 **优化后的理解**：
+- **Context（上下文）**：[推断的身份、技术栈（如果项目上下文可用）、场景、目标]
+- **Task（任务）**：[明确的动作 + 量化要求]
+- **Format（格式）**：[期望的输出形式]
+
+✅ **优化后的完整提示词**：
+
+[这里是优化后的完整提示词，要完整、详细、结构化]
+```
+
+## 示例
+
+### 示例1：模糊需求
+
+**输入**：
+```
+做个登录功能
+```
+
+**输出**：
+```markdown
+📝 **原始输入**：做个登录功能
+
+🔄 **优化后的理解**：
+- **Context（上下文）**：Web应用，资深全栈工程师，生产级安全要求
+- **Task（任务）**：实现完整的用户登录功能，包括前端表单、后端验证、token生成、会话管理
+- **Format（格式）**：完整代码文件 + 关键逻辑注释 + 测试用例
+
+✅ **优化后的完整提示词**：
+
+**任务**：实现用户登录功能
+
+**上下文**：
+- 身份：资深全栈工程师
+- 技术栈：[从项目推断或使用通用栈]
+- 安全要求：生产级别
+
+**具体要求**：
+1. 使用JWT做token认证
+2. 密码用bcrypt加密存储
+3. 登录失败3次锁定账号10分钟
+4. 成功后返回用户信息和token
+
+**输出格式**：
+- 完整的前后端代码文件
+- 关键逻辑注释
+- 安全最佳实践说明（防SQL注入、XSS）
+- 测试用例
+```
+
+---
+
+### 示例2：Debug场景
+
+**输入**：
+```
+这个报错怎么回事
+```
+
+**输出**：
+```markdown
+📝 **原始输入**：这个报错怎么回事
+
+🔄 **优化后的理解**：
+- **Context（上下文）**：遇到代码错误，需要Debug专家分析
+- **Task（任务）**：定位错误根因并提供修复方案
+- **Format（格式）**：问题原因 + 修复代码 + 预防建议
+
+✅ **优化后的完整提示词**：
+
+**任务**：分析并修复错误
+
+**上下文**：
+- 身份：资深Debug专家
+- 目标：找到根因并修复
+
+**分析步骤**：
+1. 阅读错误堆栈，定位问题代码位置
+2. 分析可能原因（类型错误/空值/逻辑错误）
+3. 检查相关上下文代码
+
+**输出要求**：
+- 问题原因（一句话）
+- 修复方案（代码）
+- 防止再次发生的建议
+
+**自我检查**：
+修复后确认类型安全，不引入新问题
+```
+
+---
+
+## 重要提醒
+
+**【格式说明】回复请以优化结果开头**：
+- 每条回复的**第一行**请使用 `📝 **原始输入**：`
+- 然后是 `🔄 **优化后的理解**：`
+- 然后是 `✅ **优化后的完整提示词**：`
+- 最后才是执行任务的内容
+- 先展示对用户输入的理解，再执行任务，这样用户可以看到提示词优化过程
+
+其他规则：
+1. **保持原始意图**，不要改变用户的核心需求
+2. **如果用户输入已经很清晰**，优化部分可以简洁，但格式必须完整
+3. **从项目上下文推断技术栈**（如果可用），不要硬编码特定技术