Skill Management

{"assessment": {"minStars": 10, "maxDaysSinceUpdate": 180, "requiredFiles": ["SKILL.md"], "allowedDependencies": ["python", "node", "bun"], "blockedPatterns": ["eval", "exec", "system"], "rationalityWeight": 0.3, "functionalityWeight": 0.3, "activityWeight": 0.2, "securityWeight": 0.2}, "security": {"auditLevel": "strict", "checkNetworkAccess": true, "checkFilePermissions": true, "maxDependencyCount": 50, "dangerousFunctions": {"high": ["eval", "exec", "system", "os.system"], "medium": ["subprocess", "child_process", "shell.exec"], "low": ["open", "write", "read"]}, "secretPatterns": ["password\\s*=", "api_key\\s*=", "secret\\s*=", "token\\s*=", "private_key"]}, "integration": {"testTimeout": 300, "regressionTests": true, "compatibilityCheck": true, "conflictDetection": {"checkNameConflicts": true, "checkDependencyConflicts": true, "checkNamespaceConflicts": true}}, "notification": {"onDecisionPoint": true, "onCompletion": true, "onError": true, "onWarning": true, "channel": "console", "logFile": "notifications.log"}, "adaptation": {"autoFixPaths": true, "preserveOriginals": true, "backupBeforeModify": true, "pathMappings": {"~/.pi/agent/skills": "${SKILLS_DIR}", "~/.claude/skills": "${CLAUDE_SKILLS_DIR}"}}, "pipeline": {"defaultPhases": ["discover", "assess", "audit", "adapt", "integrate", "report", "notify"], "interactiveMode": false, "stopOnError": true, "verbose": false}, "reports": {"outputDir": "reports", "format": "markdown", "includeDetails": true, "includeRecommendations": true, "keepHistory": true}}

#!/usr/bin/env bun

/**
 * 智能评估脚本 - 使用 LLM 进行智能分析和判断
 */

import { $ } from 'bun';

interface AssessmentOptions {
  llm?: boolean;
  verbose?: boolean;
}

interface SkillType {
  type: 'knowledge' | 'tool' | 'hybrid';
  confidence: number;
  reason: string;
}

interface AssessmentResult {
  skillName: string;
  skillType: SkillType;
  rationality: boolean;
  score: number;
  details: any;
  llmAnalysis?: string;
  issues: string[];
  strengths: string[];
  weaknesses: string[];
}

async function assessSkill(skillPath: string, options: AssessmentOptions = {}) {
  const skillName = skillPath.split('/').pop() || skillPath;
  console.log(`\n🤖 智能评估: ${skillName}`);
  console.log('━'.repeat(60));

  const result: AssessmentResult = {
    skillName,
    skillType: { type: 'knowledge', confidence: 0, reason: '' },
    rationality: true,
    score: 0,
    details: {},
    issues: [],
    strengths: [],
    weaknesses: []
  };

  // 步骤 1: 收集技能信息
  console.log(`\n📥 收集技能信息...`);
  const skillInfo = await collectSkillInfo(skillPath);
  result.details = skillInfo;

  // 步骤 2: LLM 智能识别技能类型
  console.log(`\n🧠 LLM 识别技能类型...`);
  const skillType = await identifySkillType(skillInfo);
  result.skillType = skillType;
  console.log(`   类型: ${skillType.type} (置信度: ${skillType.confidence}%)`);
  console.log(`   原因: ${skillType.reason}`);

  // 步骤 3: LLM 深度分析
  console.log(`\n🔍 LLM 深度分析...`);
  const llmAnalysis = await performLLMAnalysis(skillInfo, skillType);
  result.llmAnalysis = llmAnalysis;

  // 步骤 4: 解析 LLM 分析结果
  console.log(`\n📊 解析分析结果...`);
  const parsed = parseLLMAnalysis(llmAnalysis, skillType);
  result.rationality = parsed.rationality;
  result.score = parsed.score;
  result.issues.push(...parsed.issues);
  result.strengths.push(...parsed.strengths);
  result.weaknesses.push(...parsed.weaknesses);

  // 输出结果
  console.log(`\n✅ 评估完成`);
  console.log(`   技能类型: ${result.skillType.type}`);
  console.log(`   综合评分: ${result.score}/100`);
  console.log(`   合理性: ${result.rationality ? '✅ 通过' : '❌ 不通过'}`);

  if (result.strengths.length > 0) {
    console.log(`\n💪 优势 (${result.strengths.length}):`);
    result.strengths.slice(0, 3).forEach((s, i) => {
      console.log(`   ${i + 1}. ${s}`);
    });
  }

  if (result.issues.length > 0) {
    console.log(`\n⚠️  问题 (${result.issues.length}):`);
    result.issues.slice(0, 3).forEach((issue, i) => {
      console.log(`   ${i + 1}. ${issue}`);
    });
  }

  return result;
}

async function collectSkillInfo(skillPath: string) {
  const info: any = {
    path: skillPath,
    files: [],
    structure: {},
    content: {}
  };

  // 读取 SKILL.md
  const skillFile = `${skillPath}/SKILL.md`;
  if (await $`test -f ${skillFile}`.quiet().then(() => true).catch(() => false)) {
    info.content.skill = await Bun.file(skillFile).text();
  }

  // 列出所有文件
  const findProc = await $`find ${skillPath} -type f`.quiet();
  info.files = findProc.stdout.toString().trim().split('\n').filter(Boolean);

  // 检查目录结构
  const dirs = ['scripts', 'references', 'assets'];
  for (const dir of dirs) {
    const exists = await $`test -d ${skillPath}/${dir}`.quiet().then(() => true).catch(() => false);
    info.structure[dir] = {
      exists,
      files: exists ? await countFiles(`${skillPath}/${dir}`) : 0
    };
  }

  // 读取脚本文件内容
  if (info.structure.scripts.exists) {
    info.content.scripts = {};
    for (const file of info.files) {
      if (file.includes('/scripts/')) {
        const name = file.split('/').pop();
        try {
          info.content.scripts[name!] = await Bun.file(file).text();
        } catch (e) {
          info.content.scripts[name!] = '[读取失败]';
        }
      }
    }
  }

  // 读取参考资料
  if (info.structure.references.exists) {
    info.content.references = {};
    for (const file of info.files) {
      if (file.includes('/references/')) {
        const name = file.split('/').pop();
        try {
          info.content.references[name!] = await Bun.file(file).text();
        } catch (e) {
          info.content.references[name!] = '[读取失败]';
        }
      }
    }
  }

  // 读取依赖文件
  const requirementsPath = `${skillPath}/requirements.txt`;
  if (await $`test -f ${requirementsPath}`.quiet().then(() => true).catch(() => false)) {
    info.content.dependencies = await Bun.file(requirementsPath).text();
  }

  const packageJsonPath = `${skillPath}/package.json`;
  if (await $`test -f ${packageJsonPath}`.quiet().then(() => true).catch(() => false)) {
    info.content.packageJson = await Bun.file(packageJsonPath).text();
  }

  return info;
}

/**
 * LLM 智能识别技能类型
 */
async function identifySkillType(skillInfo: any): Promise<SkillType> {
  const prompt = generateTypeIdentificationPrompt(skillInfo);

  // 写入提示文件
  const promptFile = '/tmp/skill-type-identification.md';
  await Bun.write(promptFile, prompt);

  console.log(`   提示文件: ${promptFile}`);
  console.log(`   ⚠️  请 LLM 读取此文件并识别技能类型`);

  // 返回默认值，实际类型由 LLM 确定
  return {
    type: 'knowledge',
    confidence: 0,
    reason: '等待 LLM 分析'
  };
}

function generateTypeIdentificationPrompt(skillInfo: any): string {
  return `# 技能类型识别请求

请分析以下技能，识别其类型并给出置信度。

## 技能信息

### SKILL.md 内容
\`\`\`
${skillInfo.content.skill || '无 SKILL.md 文件'}
\`\`\`

### 目录结构
- scripts/: ${skillInfo.structure.scripts?.exists ? `✅ 存在 (${skillInfo.structure.scripts.files} 个文件)` : '❌ 不存在'}
- references/: ${skillInfo.structure.references?.exists ? `✅ 存在 (${skillInfo.structure.references.files} 个文件)` : '❌ 不存在'}
- assets/: ${skillInfo.structure.assets?.exists ? `✅ 存在 (${skillInfo.structure.assets.files} 个文件)` : '❌ 不存在'}

### 文件列表
${skillInfo.files.map(f => `- ${f}`).join('\n')}

### 脚本内容 (${Object.keys(skillInfo.content.scripts || {}).length} 个)
${Object.keys(skillInfo.content.scripts || {}).map(name => `#### ${name}\n\`\`\`\n${skillInfo.content.scripts[name].substring(0, 200)}...\n\`\`\``).join('\n\n')}

### 参考资料 (${Object.keys(skillInfo.content.references || {}).length} 个)
${Object.keys(skillInfo.content.references || {}).map(name => `- ${name}`).join('\n')}

### 依赖项
\`\`\`
Python: ${skillInfo.content.dependencies || '无'}
\`\`\`

\`\`\`
Node.js: ${skillInfo.content.packageJson || '无'}
\`\`\`

## 技能类型定义

### 1. 知识型 (knowledge)
- 主要提供知识、指南、最佳实践
- SKILL.md 包含详细的说明和示例
- 可能没有 scripts/ 目录
- 适合作为参考文档使用
- 例如: React Best Practices, Code Style Guide

### 2. 工具型 (tool)
- 提供可执行的脚本和工具
- 有 scripts/ 目录，包含可执行代码
- 可能需要依赖项
- 适合执行特定任务
- 例如: PDF 处理工具, 代码格式化器

### 3. 混合型 (hybrid)
- 既有知识内容，也有工具脚本
- SKILL.md 包含说明，scripts/ 包含工具
- references/ 可能包含详细文档
- 适合学习和实践结合
- 例如: Office 文档处理技能

## 输出格式

请按照以下格式输出识别结果：

\`\`\`json
{
  "type": "knowledge|tool|hybrid",
  "confidence": 0-100,
  "reason": "详细的判断理由",
  "characteristics": ["特征1", "特征2", ...]
}
\`\`\`

## 判断依据

请根据以下特征判断：
- SKILL.md 的内容和结构
- 是否有 scripts/ 目录及其内容
- 是否有 references/ 目录及其内容
- 是否有 assets/ 目录及其内容
- 依赖项的有无和类型
- 文件数量和类型

## 注意事项

- 知识型技能即使没有 scripts/ 目录也可能是优秀的
- 工具型技能的 SKILL.md 可能相对简单
- 混合型技能兼具两者特点
- 给出具体的判断理由
`;
}

/**
 * LLM 深度分析
 */
async function performLLMAnalysis(skillInfo: any, skillType: SkillType): Promise<string> {
  const prompt = generateAnalysisPrompt(skillInfo, skillType);

  // 写入提示文件
  const promptFile = '/tmp/skill-assessment-prompt.md';
  await Bun.write(promptFile, prompt);

  console.log(`   分析提示: ${promptFile}`);
  console.log(`   ⚠️  请 LLM 读取此文件并进行深度分析`);

  return prompt;
}

function generateAnalysisPrompt(skillInfo: any, skillType: SkillType): string {
  const typeSpecificGuidance = {
    knowledge: `
## 知识型技能评估重点

知识型技能主要评估：
1. **内容质量** - SKILL.md 的内容是否专业、准确、完整
2. **结构清晰** - 内容组织是否清晰，易于理解
3. **实用性** - 是否提供实际可用的指导和示例
4. **权威性** - 内容来源是否可靠，是否有参考价值
5. **完整性** - 是否覆盖了相关主题的主要方面

**不要求**：
- scripts/ 目录（知识型可能没有）
- references/ 目录（SKILL.md 本身可能已包含）
- assets/ 目录（知识型可能不需要）

**评分标准**：
- 内容质量 (40分)
- 结构清晰 (20分)
- 实用性 (20分)
- 权威性 (10分)
- 完整性 (10分)
`,
    tool: `
## 工具型技能评估重点

工具型技能主要评估：
1. **功能完整性** - 工具是否实现了预期的功能
2. **代码质量** - 脚本代码是否清晰、可维护
3. **错误处理** - 是否有适当的错误处理
4. **文档说明** - SKILL.md 是否清楚地说明如何使用
5. **依赖管理** - 依赖项是否合理、必要

**要求**：
- scripts/ 目录（工具型必须有）
- 清晰的使用说明
- 适当的错误处理

**评分标准**：
- 功能完整性 (30分)
- 代码质量 (25分)
- 错误处理 (20分)
- 文档说明 (15分)
- 依赖管理 (10分)
`,
    hybrid: `
## 混合型技能评估重点

混合型技能主要评估：
1. **知识内容** - SKILL.md 的内容质量
2. **工具功能** - 脚本工具的功能和代码质量
3. **整合程度** - 知识和工具是否很好地结合
4. **文档完整** - 是否有详细的参考资料
5. **实用性** - 是否能真正帮助用户完成任务

**要求**：
- SKILL.md 内容完整
- scripts/ 目录有实用工具
- references/ 可选但推荐

**评分标准**：
- 知识内容 (30分)
- 工具功能 (30分)
- 整合程度 (20分)
- 文档完整 (10分)
- 实用性 (10分)
`
  };

  return `# 技能深度分析请求

请对以下技能进行全面分析，按照技能类型使用相应的评估标准。

## 技能类型

**类型**: ${skillType.type}
**置信度**: ${skillType.confidence}%
**判断理由**: ${skillType.reason}

${typeSpecificGuidance[skillType.type]}

## 技能信息

### SKILL.md 内容
\`\`\`
${skillInfo.content.skill || '无 SKILL.md 文件'}
\`\`\`

### 目录结构
- scripts/: ${skillInfo.structure.scripts?.exists ? `✅ 存在 (${skillInfo.structure.scripts.files} 个文件)` : '❌ 不存在'}
- references/: ${skillInfo.structure.references?.exists ? `✅ 存在 (${skillInfo.structure.references.files} 个文件)` : '❌ 不存在'}
- assets/: ${skillInfo.structure.assets?.exists ? `✅ 存在 (${skillInfo.structure.assets.files} 个文件)` : '❌ 不存在'}

### 脚本文件 (${Object.keys(skillInfo.content.scripts || {}).length} 个)
${Object.keys(skillInfo.content.scripts || {}).length > 0
  ? Object.keys(skillInfo.content.scripts || {}).map(name => `#### ${name}\n\`\`\`\n${skillInfo.content.scripts[name].substring(0, 300)}...\n\`\`\``).join('\n\n')
  : '无脚本文件'}

### 参考资料 (${Object.keys(skillInfo.content.references || {}).length} 个)
${Object.keys(skillInfo.content.references || {}).length > 0
  ? Object.keys(skillInfo.content.references || {}).map(name => `- ${name}`).join('\n')
  : '无参考资料'}

### 依赖项
\`\`\`
Python: ${skillInfo.content.dependencies || '无'}
\`\`\`

\`\`\`
Node.js: ${skillInfo.content.packageJson || '无'}
\`\`\`

## 分析要求

请从以下维度进行评估：

### 1. 内容/功能分析 (${skillType.type === 'knowledge' ? '知识内容' : skillType.type === 'tool' ? '工具功能' : '知识和工具'})
- ${skillType.type === 'knowledge' ? 'SKILL.md 的内容质量、专业性、准确性' : skillType.type === 'tool' ? '工具的功能完整性、代码质量、错误处理' : '知识内容的质量和工具功能的完整性'}
- 是否有明显的缺陷或遗漏
- 与同类技能相比的优势/劣势

### 2. 结构/组织分析
- 内容组织是否清晰
- 是否易于理解和查找
- 是否有良好的层次结构

### 3. 实用性分析
- 是否真正有用
- 是否能解决实际问题
- 是否有实际应用场景

### 4. 完整性分析
- 是否覆盖了相关主题的主要方面
- 是否有重要的遗漏
- 是否需要补充

### 5. 安全性分析
- 是否有危险操作
- 是否有硬编码敏感信息
- 依赖项是否安全

## 输出格式

请按照以下格式输出分析结果：

\`\`\`json
{
  "rationality": true/false,
  "score": 0-100,
  "breakdown": {
    "contentQuality": 0-40,
    "structure": 0-20,
    "practicality": 0-20,
    "authority": 0-10,
    "completeness": 0-10
  },
  "issues": ["问题1", "问题2", ...],
  "strengths": ["优势1", "优势2", ...],
  "weaknesses": ["劣势1", "劣势2", ...],
  "recommendations": ["建议1", "建议2", ...],
  "analysis": "详细分析文本..."
}
\`\`\`

## 注意事项

- 请仔细阅读所有内容
- 根据技能类型使用相应的评分标准
- 给出具体、可操作的建议
- 评分要客观公正
- 知识型技能不要因为没有 scripts/ 目录就扣分
- 工具型技能重点评估代码质量和功能
`;
}

function parseLLMAnalysis(llmOutput: string, skillType: SkillType): any {
  const result: any = {
    rationality: true,
    score: 50,
    breakdown: {},
    issues: [],
    strengths: [],
    weaknesses: [],
    recommendations: []
  };

  // 尝试从 LLM 输出中提取 JSON
  const jsonMatch = llmOutput.match(/```json\n([\s\S]*?)\n```/);
  if (jsonMatch) {
    try {
      const parsed = JSON.parse(jsonMatch[1]);
      return parsed;
    } catch (e) {
      // JSON 解析失败
    }
  }

  // 基于关键词的分析
  if (llmOutput.includes('优秀') || llmOutput.includes('excellent')) {
    result.score = 85;
  } else if (llmOutput.includes('良好') || llmOutput.includes('good')) {
    result.score = 70;
  } else if (llmOutput.includes('一般') || llmOutput.includes('average')) {
    result.score = 50;
  }

  result.rationality = result.score >= 50;

  return result;
}

async function countFiles(dir: string): Promise<number> {
  const proc = await $`find ${dir} -type f | wc -l`.quiet();
  return parseInt(proc.stdout.toString().trim());
}

// 解析命令行参数
const args = process.argv.slice(2);
const skillPath = args[0];

if (!skillPath) {
  console.log(`
智能评估脚本 - 使用 LLM 进行智能分析和判断

用法:
  bun scripts/assess.ts <skill-path> [选项]

选项:
  --verbose       详细输出

示例:
  bun scripts/assess.ts ~/.pi/agent/skills/react-best-practices
  bun scripts/assess.ts ~/.pi/agent/skills/office-pdf --verbose
  `);
  process.exit(1);
}

// 解析选项
const options: AssessmentOptions = {
  llm: true
};

for (let i = 1; i < args.length; i++) {
  const arg = args[i];
  if (arg === '--verbose') options.verbose = true;
}

// 执行评估
assessSkill(skillPath, options).catch(err => {
  console.error(`❌ 评估失败: ${err.message}`);
  process.exit(1);
});

#!/usr/bin/env bun

/**
 * 安全审计脚本 - 调用 LLM 进行深度安全审计
 */

import { $ } from 'bun';

interface AuditOptions {
  llm?: boolean;
  interactive?: boolean;
}

interface AuditResult {
  skillName: string;
  passed: boolean;
  security: any;
  score: number;
  issues: string[];
  recommendations: string[];
}

async function auditSkill(skillPath: string, options: AuditOptions = {}) {
  const skillName = skillPath.split('/').pop() || skillPath;
  console.log(`\n🔒 安全审计: ${skillName}`);
  console.log('━'.repeat(60));

  const result: AuditResult = {
    skillName,
    passed: true,
    security: {},
    score: 0,
    issues: [],
    recommendations: []
  };

  // 收集技能信息
  const skillInfo = await collectSkillInfo(skillPath);

  // 判断技能类型
  const skillType = await determineSkillType(skillInfo);
  console.log(`   技能类型: ${skillType}`);

  // 基础安全检查（仅对有脚本的技能）
  let basicChecks: any = { score: 50, passed: true, issues: [], findings: {} };
  if (skillInfo.hasScripts) {
    console.log(`\n🔍 执行基础安全检查...`);
    basicChecks = await performBasicSecurityChecks(skillPath);
    result.security.basic = basicChecks;
  } else {
    console.log(`   ✅ 纯知识型技能，无需基础安全检查`);
    result.security.basic = { note: "纯知识型技能，无脚本文件" };
  }

  // 调用 LLM 进行深度安全审计（始终执行）
  if (options.llm !== false) {
    console.log(`\n🤖 调用 LLM 进行深度安全审计...`);
    const llmAnalysis = await performLLMSecurityAudit(skillInfo, basicChecks, skillType);

    // 解析 LLM 分析结果
    const parsed = parseLLMAudit(llmAnalysis);
    result.security.llm = parsed;
    result.score = parsed.score;
    result.issues.push(...parsed.issues);
    result.recommendations.push(...parsed.recommendations);
    result.passed = parsed.passed;
  } else {
    result.score = basicChecks.score;
    result.issues.push(...basicChecks.issues);
    result.passed = basicChecks.passed;
  }

  // 输出结果
  console.log(`\n✅ 审计完成`);
  console.log(`   安全评分: ${result.score}/100`);
  console.log(`   审计结果: ${result.passed ? '✅ 通过' : '❌ 未通过'}`);

  if (result.issues.length > 0) {
    console.log(`\n⚠️  发现 ${result.issues.length} 个安全问题:`);
    result.issues.forEach((issue, i) => {
      console.log(`   ${i + 1}. ${issue}`);
    });
  }

  if (result.recommendations.length > 0) {
    console.log(`\n💡 修复建议:`);
    result.recommendations.forEach((rec, i) => {
      console.log(`   ${i + 1}. ${rec}`);
    });
  }

  return result;
}

async function collectSkillInfo(skillPath: string) {
  const info: any = {
    path: skillPath,
    files: [],
    content: {},
    hasScripts: false
  };

  // 读取 SKILL.md
  const skillFile = `${skillPath}/SKILL.md`;
  if (await $`test -f ${skillFile}`.quiet().then(() => true).catch(() => false)) {
    info.content.skill = await Bun.file(skillFile).text();
  }

  // 列出所有文件
  const findProc = await $`find ${skillPath} -type f`.quiet();
  info.files = findProc.stdout.toString().trim().split('\n').filter(Boolean);

  // 检查是否有脚本文件
  info.hasScripts = info.files.some(f => f.includes('/scripts/'));

  // 读取脚本文件内容
  if (info.hasScripts) {
    info.content.scripts = {};
    for (const file of info.files) {
      if (file.includes('/scripts/')) {
        const name = file.split('/').pop();
        try {
          info.content.scripts[name!] = await Bun.file(file).text();
        } catch (e) {
          info.content.scripts[name!] = '[读取失败]';
        }
      }
    }
  }

  // 读取依赖文件
  const requirementsPath = `${skillPath}/requirements.txt`;
  if (await $`test -f ${requirementsPath}`.quiet().then(() => true).catch(() => false)) {
    info.content.requirements = await Bun.file(requirementsPath).text();
  }

  const packageJsonPath = `${skillPath}/package.json`;
  if (await $`test -f ${packageJsonPath}`.quiet().then(() => true).catch(() => false)) {
    info.content.package = await Bun.file(packageJsonPath).text();
  }

  // 读取参考文档
  const refsPath = `${skillPath}/references`;
  if (await $`test -d ${refsPath}`.quiet().then(() => true).catch(() => false)) {
    info.content.references = {};
    const findRefs = await $`find ${refsPath} -name "*.md" -o -name "*.txt"`.quiet();
    const refFiles = findRefs.stdout.toString().trim().split('\n').filter(Boolean);

    for (const file of refFiles) {
      const name = file.split('/').pop();
      try {
        info.content.references[name!] = await Bun.file(file).text();
      } catch (e) {
        info.content.references[name!] = '[读取失败]';
      }
    }
  }

  return info;
}

/**
 * 使用 LLM 判断技能类型
 */
async function determineSkillType(skillInfo: any): Promise<string> {
  if (!skillInfo.content.skill) return 'unknown';

  const content = skillInfo.content.skill.toLowerCase();
  const hasScripts = skillInfo.hasScripts;

  // 如果有脚本文件，很可能是工具型
  if (hasScripts) {
    if (content.includes('guide') || content.includes('reference') || content.includes('best practices')) {
      return 'hybrid'; // 混合型：有脚本但主要是知识
    }
    return 'tool'; // 工具型
  }

  // 没有脚本，判断内容类型
  if (content.includes('guide') || content.includes('reference') || content.includes('best practices') ||
      content.includes('tutorial') || content.includes('documentation')) {
    return 'knowledge'; // 知识型
  }

  if (content.includes('workflow') || content.includes('process') || content.includes('steps')) {
    return 'process'; // 流程型
  }

  return 'unknown';
}

async function performBasicSecurityChecks(skillPath: string) {
  const result: any = {
    score: 50,
    passed: true,
    issues: [],
    findings: {}
  };

  const scriptsPath = `${skillPath}/scripts`;

  // 检查危险函数
  const dangerousPatterns = {
    eval: 'eval() 执行动态代码',
    exec: 'exec() 执行系统命令',
    system: 'system() 执行 shell 命令',
    subprocess: 'subprocess 执行外部命令',
    'os.system': 'os.system() 执行系统命令'
  };

  if (await $`test -d ${scriptsPath}`.quiet().then(() => true).catch(() => false)) {
    for (const [pattern, desc] of Object.entries(dangerousPatterns)) {
      const grepProc = await $`grep -r "${pattern}" ${scriptsPath} 2>/dev/null || true`.quiet();
      const matches = grepProc.stdout.toString().trim();

      if (matches) {
        const count = matches.split('\n').filter(Boolean).length;
        result.findings[pattern] = { count, desc };
        if (pattern === 'eval' || pattern === 'exec' || pattern === 'system' || pattern === 'os.system') {
          result.issues.push(`高危函数 ${desc} (${count} 处)`);
          result.passed = false;
          result.score -= 10;
        } else {
          result.score -= 5;
        }
      }
    }

    // 检查硬编码凭据
    const secretPatterns = [
      'password\\s*=',
      'api_key\\s*=',
      'secret\\s*=',
      'token\\s*=',
      'private_key'
    ];

    for (const pattern of secretPatterns) {
      const grepProc = await $`grep -rE "${pattern}" ${scriptsPath} 2>/dev/null || true`.quiet();
      const matches = grepProc.stdout.toString().trim();

      if (matches) {
        result.issues.push(`可能包含硬编码凭据: ${pattern}`);
        result.passed = false;
        result.score -= 5;
      }
    }

    // 检查网络访问
    const netPatterns = ['http://', 'https://', 'requests.get', 'fetch(', 'axios'];
    for (const pattern of netPatterns) {
      const grepProc = await $`grep -r "${pattern}" ${scriptsPath} 2>/dev/null || true`.quiet();
      const matches = grepProc.stdout.toString().trim();

      if (matches) {
        const count = matches.split('\n').filter(Boolean).length;
        result.findings[`network_${pattern}`] = { count };
        result.score -= 2;
      }
    }
  }

  result.score = Math.max(0, result.score);

  return result;
}

/**
 * 调用 LLM 进行深度安全审计
 */
async function performLLMSecurityAudit(skillInfo: any, basicChecks: any, skillType: string): Promise<string> {
  // 生成审计提示
  const prompt = generateSecurityAuditPrompt(skillInfo, basicChecks, skillType);

  // 将提示写入临时文件，供主 LLM 分析
  const promptFile = '/tmp/skill-security-audit-prompt.md';
  await Bun.write(promptFile, prompt);

  console.log(`   审计提示已生成: ${promptFile}`);
  console.log(`   请让 Claude 阅读该文件并进行分析`);

  return prompt;
}

function generateSecurityAuditPrompt(skillInfo: any, basicChecks: any, skillType: string): string {
  let contentAnalysis = '### SKILL.md 内容\n```';
  if (skillInfo.content.skill) {
    contentAnalysis += skillInfo.content.skill.substring(0, 3000);
    if (skillInfo.content.skill.length > 3000) {
      contentAnalysis += '\n...(内容已截断)';
    }
  }
  contentAnalysis += '```\n';

  // 添加脚本内容
  if (skillInfo.hasScripts && skillInfo.content.scripts) {
    contentAnalysis += '\n### 脚本文件\n';
    Object.keys(skillInfo.content.scripts).forEach(name => {
      const scriptContent = skillInfo.content.scripts[name];
      contentAnalysis += `\n#### ${name}\n\`\`\`\n${scriptContent.substring(0, 500)}...\n\`\`\`\n`;
    });
  }

  // 添加依赖信息
  contentAnalysis += '\n### 依赖项\n```';
  if (skillInfo.content.requirements) {
    contentAnalysis += `Python:\n${skillInfo.content.requirements}`;
  }
  if (skillInfo.content.package) {
    contentAnalysis += `\nNode.js:\n${skillInfo.content.package}`;
  }
  contentAnalysis += '```\n';

  return `# 技能安全审计请求

## 技能信息

**技能类型:** ${skillType}
**是否有脚本:** ${skillInfo.hasScripts ? '是' : '否'}
**文件数量:** ${skillInfo.files.length}

${contentAnalysis}

## 基础安全检查结果
\`\`\`json
${JSON.stringify(basicChecks, null, 2)}
\`\`\`

## 审计要求

请根据技能类型（${skillType}）进行相应的安全审计：

### 如果是知识型技能（knowledge）
重点审查：
- **内容安全性**: 文档中是否包含危险操作示例？
- **误导性内容**: 是否有错误的安全建议？
- **敏感信息**: 文档中是否泄露敏感信息？
- **链接安全**: 外部链接是否安全可信？

### 如果是工具型技能（tool）
重点审查：
- **代码安全**: 危险函数、命令注入、路径遍历
- **依赖安全**: 依赖漏洞、来源可信度
- **数据安全**: 敏感信息、数据泄露
- **权限安全**: 文件权限、网络访问、系统调用
- **错误处理**: 错误信息泄露、异常处理

### 如果是混合型技能（hybrid）
同时审查知识型和工具型的所有维度

### 如果是流程型技能（process）
重点审查：
- **流程安全性**: 流程步骤是否有安全风险？
- **输入验证**: 流程中是否有用户输入验证？
- **输出安全**: 流程输出是否安全？

## 输出格式

请按照以下格式输出审计结果：

\`\`\`json
{
  "passed": true/false,
  "score": 0-100,
  "severity": "high/medium/low/none",
  "skillType": "${skillType}",
  "issues": [
    {
      "type": "类型",
      "severity": "high/medium/low",
      "description": "问题描述",
      "location": "位置",
      "recommendation": "修复建议"
    }
  ],
  "findings": {
    "contentIssues": [],
    "codeIssues": [],
    "dependencyIssues": [],
    "otherIssues": []
  },
  "recommendations": ["建议1", "建议2", ...],
  "analysis": "详细审计分析..."
}
\`\`\`

## 审计标准

### 高风险 (high)
- 存在可被利用的安全漏洞
- 硬编码敏感信息
- 未经验证的用户输入
- 危险的系统调用
- 误导性的安全建议（知识型）

### 中风险 (medium)
- 潜在的安全问题
- 不完善的错误处理
- 可疑的依赖项
- 不明确的最佳实践

### 低风险 (low)
- 代码质量问题
- 最佳实践建议
- 优化建议

### 无风险 (none)
- 纯知识型且内容安全
- 无任何安全问题

## 注意事项

- 根据技能类型调整审计重点
- 对于知识型技能，重点关注内容质量而非代码安全
- 给出具体、可操作的建议
- 评分要客观公正
`;
}

function parseLLMAudit(llmOutput: string): any {
  const result: any = {
    passed: true,
    score: 50,
    severity: 'none',
    issues: [],
    recommendations: []
  };

  // 尝试从 LLM 输出中提取 JSON
  const jsonMatch = llmOutput.match(/```json\n([\s\S]*?)\n```/);
  if (jsonMatch) {
    try {
      const parsed = JSON.parse(jsonMatch[1]);
      result.passed = parsed.passed;
      result.score = parsed.score;
      result.severity = parsed.severity;
      result.issues = parsed.issues?.map((i: any) =>
        typeof i === 'string' ? i : `${i.type}: ${i.description}`
      ) || [];
      result.recommendations = parsed.recommendations || [];
      return result;
    } catch (e) {
      // JSON 解析失败
    }
  }

  // 基于关键词的分析
  if (llmOutput.includes('高风险') || llmOutput.includes('high')) {
    result.score -= 30;
    result.passed = false;
    result.severity = 'high';
  }
  if (llmOutput.includes('中风险') || llmOutput.includes('medium')) {
    result.score -= 15;
    result.severity = 'medium';
  }
  if (llmOutput.includes('无风险') || llmOutput.includes('none')) {
    result.score = 100;
    result.severity = 'none';
  }

  result.score = Math.max(0, Math.min(100, result.score));

  return result;
}

// 解析命令行参数
const args = process.argv.slice(2);
const skillPath = args[0];

if (!skillPath) {
  console.log(`
安全审计脚本 - 调用 LLM 进行深度安全审计

用法:
  bun scripts/audit.ts <skill-path> [选项]

选项:
  --no-llm         不使用 LLM，仅进行基础审计
  --interactive    交互式模式（需要用户介入）

示例:
  bun scripts/audit.ts ~/.pi/agent/skills/office-pdf
  bun scripts/audit.ts ~/.pi/agent/skills/react-best-practices
  bun scripts/audit.ts ~/.pi/agent/skills/office-pdf --no-llm
  `);
  process.exit(1);
}

// 解析选项
const options: AuditOptions = {
  llm: true
};

for (let i = 1; i < args.length; i++) {
  const arg = args[i];
  if (arg === '--no-llm') options.llm = false;
  else if (arg === '--interactive') options.interactive = true;
}

// 执行审计
auditSkill(skillPath, options).catch(err => {
  console.error(`❌ 审计失败: ${err.message}`);
  process.exit(1);
});

#!/usr/bin/env bun

/**
 * 用户交互脚本 - 使用 interview 工具进行用户介入决策
 */

import { $ } from 'bun';

interface InteractiveOptions {
  phase?: string;
  message?: string;
  promptFile?: string;
  issues?: string[];
}

async function interactiveDecision(options: InteractiveOptions = {}) {
  const { phase, message, promptFile, issues } = options;

  console.log(`\n🤔 用户介入请求`);
  console.log('━'.repeat(60));

  // 读取 LLM 分析结果
  let analysisContent = '';
  if (promptFile && await $`test -f ${promptFile}`.quiet().then(() => true).catch(() => false)) {
    console.log(`\n📄 读取分析结果: ${promptFile}`);
    analysisContent = await Bun.file(promptFile).text();
    console.log(`   分析内容长度: ${analysisContent.length} 字符`);
  }

  // 生成 interview 问题配置
  const interviewConfig = generateInterviewConfig(phase, message, issues, analysisContent);

  // 写入配置文件
  const configFile = `${process.env.HOME}/.pi/agent/skills/skill-management/.interview-config.json`;
  await Bun.write(configFile, JSON.stringify(interviewConfig, null, 2));

  console.log(`\n💡 Interview 配置已生成: ${configFile}`);
  console.log(`\n📝 请 Claude 使用 interview 工具询问用户:`);
  console.log(`   interview ${configFile}`);

  console.log(`\n⚠️  等待用户决策...`);

  return { configFile };
}

function generateInterviewConfig(
  phase?: string,
  message?: string,
  issues?: string[],
  analysisContent?: string
) {
  const questions: any[] = [];

  // 基础问题：是否继续
  questions.push({
    id: 'continue',
    type: 'single',
    question: message || '是否继续流程？',
    options: ['继续', '停止', '跳过当前阶段'],
    recommended: '继续'
  });

  // 如果有分析内容，添加相关问题
  if (analysisContent && analysisContent.length > 0) {
    questions.push({
      id: 'review_analysis',
      type: 'single',
      question: 'LLM 分析结果是否可接受？',
      options: ['完全接受', '部分接受', '不接受'],
      recommended: '部分接受'
    });

    questions.push({
      id: 'analysis_score',
      type: 'single',
      question: 'LLM 给出的评分是否合理？',
      options: ['合理', '偏高', '偏低'],
      recommended: '合理'
    });
  }

  // 如果有问题列表，添加反馈问题
  if (issues && issues.length > 0) {
    questions.push({
      id: 'address_issues',
      type: 'multi',
      question: '发现以下问题，请选择需要立即修复的：',
      options: issues.slice(0, 10), // 限制最多 10 个选项
      recommended: []
    });

    questions.push({
      id: 'issue_action',
      type: 'single',
      question: '对于未修复的问题，希望如何处理？',
      options: ['记录并继续', '暂时跳过', '停止流程等待修复'],
      recommended: '记录并继续'
    });
  }

  // 阶段特定问题
  if (phase === 'assess') {
    questions.push({
      id: 'skill_rationality',
      type: 'single',
      question: '该技能的合理性评估：',
      options: ['完全合理', '基本合理', '需要改进', '不合理'],
      recommended: '基本合理'
    });
  }

  if (phase === 'audit') {
    questions.push({
      id: 'security_acceptance',
      type: 'single',
      question: '安全审计结果：',
      options: ['安全可用', '存在低风险可接受', '存在中风险需考虑', '存在高风险不可用'],
      recommended: '存在低风险可接受'
    });
  }

  if (phase === 'adapt') {
    questions.push({
      id: 'adapt_action',
      type: 'single',
      question: '是否需要进行适应性改造？',
      options: ['立即改造', '稍后改造', '无需改造'],
      recommended: '立即改造'
    });
  }

  // 添加反馈问题
  questions.push({
    id: 'feedback',
    type: 'text',
    question: '请提供任何额外的反馈或要求：',
    recommended: ''
  });

  return {
    title: `技能管理流程 - ${phase || '决策点'}`,
    description: message || '请根据 LLM 分析结果做出决策',
    questions
  };
}

// 解析命令行参数
const args = process.argv.slice(2);

if (args.length === 0) {
  console.log(`
用户交互脚本 - 使用 interview 工具进行用户介入决策

用法:
  bun scripts/interactive.ts [选项]

选项:
  --phase <phase>       当前阶段
  --message <msg>       决策消息
  --prompt-file <file>  LLM 分析提示文件
  --issues <issue1,issue2,...>  问题列表（逗号分隔）

示例:
  # 评估阶段决策
  bun scripts/interactive.ts --phase assess --message "评估已完成，是否继续？"

  # 审计阶段决策（带分析结果）
  bun scripts/interactive.ts --phase audit --message "审计已完成" --prompt-file /tmp/skill-security-audit-prompt.md

  # 改造阶段决策（带问题列表）
  bun scripts/interactive.ts --phase adapt --message "发现需要适配的路径" --issues "路径1,路径2,路径3"

# 使用 interview 工具
# Claude 应该使用以下命令询问用户：
# interview ~/.pi/agent/skills/skill-management/.interview-config.json
  `);
  process.exit(1);
}

// 解析选项
const options: InteractiveOptions = {};
for (let i = 0; i < args.length; i++) {
  const arg = args[i];
  if (arg === '--phase' && args[i + 1]) {
    options.phase = args[i + 1];
    i++;
  } else if (arg === '--message' && args[i + 1]) {
    options.message = args[i + 1];
    i++;
  } else if (arg === '--prompt-file' && args[i + 1]) {
    options.promptFile = args[i + 1];
    i++;
  } else if (arg === '--issues' && args[i + 1]) {
    options.issues = args[i + 1].split(',');
    i++;
  }
}

// 执行交互
interactiveDecision(options).catch(err => {
  console.error(`❌ 交互失败: ${err.message}`);
  process.exit(1);
});

#!/usr/bin/env bun

/**
 * 通知脚本 - 向用户发送技能管理流程的通知
 */

import { $ } from 'bun';

interface NotifyOptions {
  type?: 'decision' | 'progress' | 'complete' | 'error' | 'warning';
  skill?: string;
  message?: string;
  phase?: string;
  report?: string;
  channel?: 'console' | 'file' | 'both';
}

async function notify(options: NotifyOptions = {}) {
  const {
    type = 'info',
    skill,
    message,
    phase,
    report,
    channel = 'console'
  } = options;

  const notification = buildNotification(type, skill, message, phase, report);

  if (channel === 'console' || channel === 'both') {
    console.log(notification);
  }

  if (channel === 'file' || channel === 'both') {
    const logPath = `${process.env.HOME}/.pi/agent/skills/skill-management/notifications.log`;
    await Bun.appendFile(logPath, `\n${new Date().toISOString()}\n${notification}\n`);
  }

  return { success: true };
}

function buildNotification(
  type: string,
  skill?: string,
  message?: string,
  phase?: string,
  report?: string
): string {
  const icons = {
    decision: '🤔',
    progress: '⏳',
    complete: '✅',
    error: '❌',
    warning: '⚠️',
    info: 'ℹ️'
  };

  const icon = icons[type as keyof typeof icons] || icons.info;

  let output = `\n${icon} ${type.toUpperCase()}`;

  if (skill) output += ` - ${skill}`;
  output += '\n' + '━'.repeat(60);

  if (phase) output += `\n\n📍 阶段: ${phase}`;
  if (message) output += `\n\n📝 ${message}`;
  if (report) output += `\n\n📄 报告: ${report}`;

  switch (type) {
    case 'decision':
      output += `\n\n⏸️  流程暂停，等待用户确认`;
      output += `\n\n操作选项:`;
      output += `\n  [Y] 继续`;
      output += `\n  [N] 停止`;
      output += `\n  [S] 跳过当前阶段`;
      break;

    case 'progress':
      output += `\n\n🔄 流程进行中...`;
      break;

    case 'complete':
      output += `\n\n🎉 流程顺利完成！`;
      output += `\n\n后续步骤:`;
      output += `\n  1. 查看详细报告`;
      output += `\n  2. 测试技能功能`;
      output += `\n  3. 根据建议优化`;
      break;

    case 'error':
      output += `\n\n🚨 发生错误，流程终止`;
      output += `\n\n排查建议:`;
      output += `\n  1. 检查错误日志`;
      output += `\n  2. 验证输入参数`);
      output += `\n  3. 重试流程`;
      break;

    case 'warning':
      output += `\n\n⚠️  注意事项`;
      output += `\n\n建议:`;
      output += `\n  1. 仔细阅读警告信息`);
      output += `\n  2. 评估潜在风险`;
      output += `\n  3. 采取相应措施`;
      break;
  }

  output += '\n';

  return output;
}

// 解析命令行参数
const args = process.argv.slice(2);

if (args.length === 0) {
  console.log(`
通知脚本 - 向用户发送技能管理流程的通知

用法:
  bun scripts/notify.ts [选项]

选项:
  --type <type>       通知类型 (decision, progress, complete, error, warning)
  --skill <name>      技能名称
  --message <msg>     通知消息
  --phase <phase>     当前阶段
  --report <path>     报告路径
  --channel <channel> 通知渠道 (console, file, both)

示例:
  # 决策点通知
  bun scripts/notify.ts --type decision --skill office-pdf --message "需要确认是否继续"

  # 进度通知
  bun scripts/notify.ts --type progress --skill office-pdf --phase "Phase 3: 安全审计"

  # 完成通知
  bun scripts/notify.ts --type complete --skill office-pdf --report reports/office-pdf.md

  # 错误通知
  bun scripts/notify.ts --type error --message "依赖安装失败"

  # 警告通知
  bun scripts/notify.ts --type warning --message "发现潜在安全风险"
  `);
  process.exit(0);
}

// 解析选项
const options: NotifyOptions = {};
for (let i = 0; i < args.length; i++) {
  const arg = args[i];
  if (arg === '--type' && args[i + 1]) {
    options.type = args[i + 1] as any;
    i++;
  } else if (arg === '--skill' && args[i + 1]) {
    options.skill = args[i + 1];
    i++;
  } else if (arg === '--message' && args[i + 1]) {
    options.message = args[i + 1];
    i++;
  } else if (arg === '--phase' && args[i + 1]) {
    options.phase = args[i + 1];
    i++;
  } else if (arg === '--report' && args[i + 1]) {
    options.report = args[i + 1];
    i++;
  } else if (arg === '--channel' && args[i + 1]) {
    options.channel = args[i + 1] as any;
    i++;
  }
}

// 发送通知
notify(options).catch(err => {
  console.error(`❌ 通知发送失败: ${err.message}`);
  process.exit(1);
});

#!/usr/bin/env bun

/**
 * 完整流程脚本 - 一键执行技能管理的完整流程，使用 interview 工具进行用户介入
 */

import { $ } from 'bun';

const SKILLS_DIR = `${process.env.HOME}/.pi/agent/skills`;
const TEMP_DIR = '/tmp/skill-pipeline';
const REPORTS_DIR = `${process.env.HOME}/.pi/agent/skills/skill-management/reports`;

interface PipelineOptions {
  interactive?: boolean;
  verbose?: boolean;
  skipAudit?: boolean;
  skipTest?: boolean;
}

async function runPipeline(keyword?: string, options: PipelineOptions = {}) {
  const phases = [
    'search',
    'select',
    'discover',
    'assess',
    'audit',
    'adapt',
    'integrate',
    'report',
    'notify'
  ];

  console.log(`\n🚀 技能管理流程启动`);
  if (keyword) console.log(`   搜索关键词: ${keyword}`);
  console.log(`   交互模式: ${options.interactive ? '✅' : '❌'}`);
  console.log('━'.repeat(60));

  const results: any = {};

  // 准备工作目录
  await $`rm -rf ${TEMP_DIR}`;
  await $`mkdir -p ${TEMP_DIR} ${REPORTS_DIR}`;

  // Phase 1: 搜索技能
  if (keyword) {
    console.log(`\n🔍 Phase 1: 搜索技能`);
    const searchResult = await searchSkills(keyword);
    results.search = searchResult;

    if (!searchResult.success || searchResult.skills.length === 0) {
      console.error(`❌ 搜索失败或未找到技能`);
      return results;
    }
  }

  // Phase 2: 选择技能
  console.log(`\n📋 Phase 2: 选择技能`);
  const selectResult = await selectSkill(results.search?.skills || [], options.interactive);
  results.select = selectResult;

  if (!selectResult.selected) {
    console.log(`⏸️  未选择技能，流程结束`);
    return results;
  }

  const selectedSkill = selectResult.selected;

  // Phase 3: 发现技能
  console.log(`\n📥 Phase 3: 发现技能`);
  const discoverResult = await discover(selectedSkill.repo, selectedSkill.name);
  results.discover = discoverResult;

  if (!discoverResult.success) {
    console.error(`❌ 发现阶段失败`);
    return results;
  }

  const skillPath = `${SKILLS_DIR}/${discoverResult.skillName}`;

  // Phase 4: 评估技能
  console.log(`\n📊 Phase 4: 评估技能`);
  const assessResult = await assess(skillPath, options.interactive);
  results.assess = assessResult;

  if (options.interactive && !assessResult.userDecision?.continue) {
    console.log(`⏸️  用户选择停止流程`);
    return results;
  }

  // Phase 5: 安全审计
  if (!options.skipAudit) {
    console.log(`\n🔒 Phase 5: 安全审计`);
    const auditResult = await audit(skillPath, options.interactive);
    results.audit = auditResult;

    if (options.interactive && !auditResult.userDecision?.continue) {
      console.log(`⏸️  用户选择停止流程`);
      return results;
    }
  }

  // Phase 6: 适应性改造
  console.log(`\n🔧 Phase 6: 适应性改造`);
  const adaptResult = await adapt(skillPath, options.interactive);
  results.adapt = adaptResult;

  // Phase 7: 融合测试
  if (!options.skipTest) {
    console.log(`\n🧪 Phase 7: 融合测试`);
    const integrateResult = await integrate(skillPath);
    results.integrate = integrateResult;
  }

  // Phase 8: 生成报告
  console.log(`\n📄 Phase 8: 生成报告`);
  const reportResult = await generateReport(discoverResult.skillName, results);
  results.report = reportResult;

  // Phase 9: 用户通知
  console.log(`\n🔔 Phase 9: 用户通知`);
  await notify(discoverResult.skillName, results);

  console.log(`\n✅ 流程完成`);
  console.log(`   技能: ${discoverResult.skillName}`);
  console.log(`   报告: ${REPORTS_DIR}/${discoverResult.skillName}.md`);

  return results;
}

async function searchSkills(keyword: string) {
  const result: any = { success: false, skills: [] };

  try {
    console.log(`   搜索: ${keyword}`);

    // 使用 gh 搜索
    const proc = Bun.spawn(['gh', 'search', 'repos', keyword, '-L', '20', '--sort', 'stars', '--order', 'desc'], {
      stdout: 'pipe',
      stderr: 'pipe'
    });

    const output = await new Response(proc.stdout).text();
    const error = await new Response(proc.stderr).text();

    if (error) {
      result.error = error;
      return result;
    }

    // 解析输出
    const lines = output.trim().split('\n');
    for (const line of lines) {
      const match = line.match(/^(\S+)\/(\S+)\s+([\d.]+★)\s+(.+)$/);
      if (match) {
        result.skills.push({
          owner: match[1],
          name: match[2],
          repo: `${match[1]}/${match[2]}`,
          stars: match[3],
          description: match[4]
        });
      }
    }

    result.success = true;
    console.log(`   找到 ${result.skills.length} 个技能`);

  } catch (error: any) {
    result.error = error.message;
  }

  return result;
}

async function selectSkill(skills: any[], interactive: boolean) {
  const result: any = { selected: null };

  if (skills.length === 0) {
    console.log(`   无技能可选择`);
    return result;
  }

  // 生成选择配置
  const selectConfig = generateSelectConfig(skills);

  // 写入配置文件
  const configFile = `${TEMP_DIR}/select-config.json`;
  await Bun.write(configFile, JSON.stringify(selectConfig, null, 2));

  console.log(`   💡 请使用 interview 工具让用户选择技能`);
  console.log(`   配置文件: ${configFile}`);

  if (interactive) {
    console.log(`\n   ⏸️  等待用户选择...`);
    // 在实际使用中，Pi Agent 会读取配置并使用 interview 工具
    // 这里只是生成配置，实际的交互由 Pi Agent 完成
  } else {
    // 非交互模式，选择第一个
    result.selected = skills[0];
    console.log(`   自动选择: ${result.selected.repo}`);
  }

  return result;
}

function generateSelectConfig(skills: any[]) {
  return {
    title: '选择要安装的技能',
    description: '根据搜索结果，请选择要安装和评估的技能',
    questions: [
      {
        id: 'skill_choice',
        type: 'single',
        question: '请选择要安装的技能：',
        options: skills.map(s => `${s.repo} ⭐ ${s.stars} - ${s.description.substring(0, 50)}...`),
        recommended: skills[0].repo
      },
      {
        id: 'custom_name',
        type: 'text',
        question: '自定义技能名称（可选，留空使用默认名称）：',
        recommended: ''
      },
      {
        id: 'feedback',
        type: 'text',
        question: '任何额外的要求或说明：',
        recommended: ''
      }
    ]
  };
}

async function discover(repo: string, skillName?: string) {
  const result: any = { success: false };

  try {
    console.log(`   克隆仓库: ${repo}`);
    const repoName = repo.split('/')[1];
    const cloneDir = `${TEMP_DIR}/${repoName}`;

    await $`gh repo clone ${repo} ${cloneDir}`;

    // 查找技能
    const skillFiles = await $`find ${cloneDir} -name "SKILL.md" -type f`.quiet();
    const skills = skillFiles.stdout.toString().trim().split('\n').filter(Boolean);

    if (skills.length === 0) {
      result.error = '未找到 SKILL.md 文件';
      return result;
    }

    // 复制技能
    const skillDir = skills[0].replace('/SKILL.md', '');
    const targetName = skillName || repoName.replace(/-skill$/, '').replace(/-skills$/, '');
    const targetPath = `${SKILLS_DIR}/${targetName}`;

    console.log(`   安装技能: ${targetName}`);
    await $`cp -r ${skillDir} ${targetPath}`;

    result.success = true;
    result.skillName = targetName;
    result.skillPath = targetPath;
    result.skillsFound = skills.length;

  } catch (error: any) {
    result.error = error.message;
  }

  return result;
}

async function assess(skillPath: string, interactive: boolean) {
  const assessScript = `${process.env.HOME}/.pi/agent/skills/skill-management/scripts/assess.ts`;

  // 生成分析提示
  await $`bun ${assessScript} ${skillPath}`.quiet();

  let userDecision: any = { continue: true };

  if (interactive) {
    console.log(`   💡 请阅读分析提示并使用 interview 工具询问用户`);
    console.log(`   分析提示: /tmp/skill-assessment-prompt.md`);
  }

  return { success: true, userDecision };
}

async function audit(skillPath: string, interactive: boolean) {
  const auditScript = `${process.env.HOME}/.pi/agent/skills/skill-management/scripts/audit.ts`;

  // 生成审计提示
  await $`bun ${auditScript} ${skillPath}`.quiet();

  let userDecision: any = { continue: true };

  if (interactive) {
    console.log(`   💡 请阅读审计提示并使用 interview 工具询问用户`);
    console.log(`   审计提示: /tmp/skill-security-audit-prompt.md`);
  }

  return { success: true, userDecision };
}

async function adapt(skillPath: string, interactive: boolean) {
  console.log(`   分析适配需求...`);
  const grepProc = await $`grep -r "home/\\.pi" ${skillPath} 2>/dev/null || true`.quiet();
  const matches = grepProc.stdout.toString().trim();

  if (matches) {
    console.log(`   ⚠️  发现 ${matches.split('\n').filter(Boolean).length} 处路径引用需要调整`);
  } else {
    console.log(`   ✅ 无需路径调整`);
  }

  return { success: true, adapted: matches.length > 0 };
}

async function integrate(skillPath: string) {
  console.log(`   检查命名冲突...`);
  const skillName = skillPath.split('/').pop()!;
  const conflict = await $`find ${SKILLS_DIR} -maxdepth 1 -name "${skillName}*" ! -path "${skillPath}" 2>/dev/null | wc -l`.quiet();
  const conflictCount = parseInt(conflict.stdout.toString().trim());

  if (conflictCount > 0) {
    console.log(`   ⚠️  发现 ${conflictCount} 个可能冲突的技能`);
  } else {
    console.log(`   ✅ 无命名冲突`);
  }

  console.log(`   ✅ 基础兼容性检查通过`);
  return { success: true, conflicts: conflictCount };
}

async function generateReport(skillName: string, results: any) {
  const reportPath = `${REPORTS_DIR}/${skillName}.md`;

  const content = `# 技能评估报告: ${skillName}

生成时间: ${new Date().toLocaleString('zh-CN')}

## 执行流程

✅ 搜索 → ✅ 选择 → ✅ 发现 → ✅ 评估 → ${results.audit ? '✅' : '⏭️'} 审计 → ✅ 改造 → ${results.integrate ? '✅' : '⏭️'} 融合 → ✅ 报告

## 技能信息

- **名称**: ${skillName}
- **仓库**: ${results.select?.selected?.repo || 'N/A'}
- **描述**: ${results.select?.selected?.description || 'N/A'}
- **星标**: ${results.select?.selected?.stars || 'N/A'}

## LLM 分析文件

- 评估分析: \`/tmp/skill-assessment-prompt.md\`
- 安全审计: \`/tmp/skill-security-audit-prompt.md\`

## 建议

1. ✅ 技能已安装到本地
2. 📝 查看 LLM 分析结果
3. 🧪 测试技能功能
4. 📚 阅读技能文档: \`${SKILLS_DIR}/${skillName}/SKILL.md\`

## 下一步

请 Pi Agent 读取 LLM 分析文件并给出详细建议。
`;

  await Bun.write(reportPath, content);
  console.log(`   报告已生成: ${reportPath}`);

  return { success: true, reportPath };
}

async function notify(skillName: string, results: any) {
  console.log(`\n📋 通知摘要`);
  console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
  console.log(`\n✅ 技能管理流程已完成`);
  console.log(`   技能: ${skillName}`);
  console.log(`   仓库: ${results.select?.selected?.repo || 'N/A'}`);
  console.log(`\n📄 LLM 分析文件:`);
  console.log(`   - 评估: /tmp/skill-assessment-prompt.md`);
  console.log(`   - 审计: /tmp/skill-security-audit-prompt.md`);
  console.log(`\n📚 技能文档: ${SKILLS_DIR}/${skillName}/SKILL.md`);
  console.log(`\n💡 下一步:`);
  console.log(`   1. 读取 LLM 分析文件`);
  console.log(`   2. 根据分析结果进行决策`);
  console.log(`   3. 测试技能功能`);
}

// 解析命令行参数
const args = process.argv.slice(2);
const keyword = args[0];

if (!keyword) {
  console.log(`
完整流程脚本 - 技能搜索、选择、安装、评估全流程

用法:
  bun scripts/pipeline.ts <keyword> [选项]

参数:
  keyword         搜索关键词（必需）

选项:
  --interactive   交互式模式（使用 interview 工具）
  --verbose       详细输出
  --skip-audit    跳过安全审计
  --skip-test     跳过融合测试

阶段:
  search    搜索技能
  select    选择技能（使用 interview）
  discover  发现并安装技能
  assess    评估技能（Pi Agent 分析）
  audit     安全审计（Pi Agent 分析）
  adapt     适应性改造
  integrate 融合测试
  report    生成报告
  notify    用户通知

示例:
  # 搜索 office 技能并选择
  bun scripts/pipeline.ts "claude office" --interactive

  # 搜索 pdf 技能
  bun scripts/pipeline.ts "pdf processing"

  # 搜索并自动选择第一个
  bun scripts/pipeline.ts "browser skill"
  `);
  process.exit(1);
}

// 解析选项
const options: PipelineOptions = {};
for (let i = 1; i < args.length; i++) {
  const arg = args[i];
  if (arg === '--interactive') {
    options.interactive = true;
  } else if (arg === '--verbose') {
    options.verbose = true;
  } else if (arg === '--skip-audit') {
    options.skipAudit = true;
  } else if (arg === '--skip-test') {
    options.skipTest = true;
  }
}

// 执行流程
runPipeline(keyword, options).catch(err => {
  console.error(`❌ 流程失败: ${err.message}`);
  process.exit(1);
});