work-agent 0.1.0

package/lib/skill-engine.ts

@@ -0,0 +1,396 @@
+/**
+ * Skill Engine
+ * 
+ * Manages skill execution, command routing, and risk assessment.
+ */
+
+import { exec, execSync, spawn, SpawnOptions } from 'child_process';
+import { promisify } from 'util';
+import { existsSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { parseCommand, extractAffectedResources, type ParsedCommand } from './command-parser';
+import { estimateRisk, type RiskLevel, getTimeoutForRisk } from './risk-estimator';
+
+const execAsync = promisify(exec);
+
+export type CommandStatus = 'pending' | 'approved' | 'rejected' | 'executing' | 'completed' | 'failed';
+
+export interface SkillResult {
+  success: boolean;
+  output?: string;
+  error?: string;
+  exitCode?: number;
+  executionTime?: number;
+}
+
+export interface ExecutionRequest {
+  command: string;
+  skillName?: string;
+  userId?: string;
+  sessionId?: string;
+  requireApproval?: boolean;
+  /** Force execution even for dangerous commands (used for approved tickets) */
+  forceExecute?: boolean;
+}
+
+export interface ExecutionResult {
+  ticketId?: string;
+  status: CommandStatus;
+  result?: SkillResult;
+  riskLevel: RiskLevel;
+  requiresApproval: boolean;
+  affectedResources?: string[];
+  command: string;
+  skillName?: string;
+}
+
+export interface SkillInfo {
+  name: string;
+  displayName?: string;
+  description?: string;
+  version?: string;
+  commandPatterns?: string[];
+}
+
+let skillCache: Map<string, SkillInfo> = new Map();
+
+export async function processCommand(request: ExecutionRequest): Promise<ExecutionResult> {
+  const { command, skillName, userId, sessionId, forceExecute } = request;
+
+  // Parse the command
+  const parsed = parseCommand(command);
+
+  // Estimate risk
+  const riskAssessment = estimateRisk(command, skillName);
+
+  // Extract affected resources
+  const affectedResources = extractAffectedResources(parsed);
+
+  // Check if approval is required
+  const requiresApproval = riskAssessment.requiresApproval || riskAssessment.shouldBlock;
+
+  // If not forcing execution, check approval requirements
+  if (!forceExecute) {
+    // If blocking (critical risk), return immediately without execution
+    if (riskAssessment.shouldBlock) {
+      return {
+        status: 'rejected',
+        riskLevel: riskAssessment.riskLevel,
+        requiresApproval: true,
+        affectedResources,
+        command,
+        skillName,
+        result: {
+          success: false,
+          error: `Command blocked: ${riskAssessment.reason}`,
+        },
+      };
+    }
+
+    // If approval required, return pending status
+    if (requiresApproval) {
+      return {
+        ticketId: generateTicketId(),
+        status: 'pending',
+        riskLevel: riskAssessment.riskLevel,
+        requiresApproval: true,
+        affectedResources,
+        command,
+        skillName,
+      };
+    }
+  }
+
+  // Execute the command directly (low/medium risk without approval requirement, or forced execution)
+  const result = await executeCommand(command, riskAssessment.riskLevel);
+  
+  return {
+    status: result.success ? 'completed' : 'failed',
+    riskLevel: riskAssessment.riskLevel,
+    requiresApproval: false,
+    affectedResources,
+    command,
+    skillName,
+    result,
+  };
+}
+
+export async function executeCommand(
+  command: string,
+  riskLevel: RiskLevel
+): Promise<SkillResult> {
+  const startTime = Date.now();
+  const timeout = getTimeoutForRisk(riskLevel);
+  
+  try {
+    // Determine if this is a complex command that needs spawning
+    const needsSpawn = command.includes('|') || command.includes('&&') || command.includes('||') || command.includes('>') || command.includes('<');
+    
+    if (needsSpawn) {
+      return await spawnCommand(command, timeout, startTime);
+    } else {
+      const { stdout, stderr } = await execAsync(command, {
+        timeout,
+        maxBuffer: 10 * 1024 * 1024, // 10MB
+      });
+      
+      return {
+        success: true,
+        output: stdout || stderr,
+        executionTime: Date.now() - startTime,
+      };
+    }
+  } catch (error: any) {
+    return {
+      success: false,
+      error: error.message,
+      exitCode: error.exitCode,
+      executionTime: Date.now() - startTime,
+    };
+  }
+}
+
+async function spawnCommand(
+  command: string,
+  timeout: number,
+  startTime: number
+): Promise<SkillResult> {
+  return new Promise((resolve) => {
+    const child = spawn(command, {
+      shell: '/bin/bash',
+      timeout,
+    });
+    
+    let stdout = '';
+    let stderr = '';
+    
+    child.stdout?.on('data', (data) => {
+      stdout += data.toString();
+    });
+    
+    child.stderr?.on('data', (data) => {
+      stderr += data.toString();
+    });
+    
+    child.on('close', (code) => {
+      resolve({
+        success: code === 0,
+        output: stdout || stderr,
+        exitCode: code || undefined,
+        executionTime: Date.now() - startTime,
+      });
+    });
+    
+    child.on('error', (error) => {
+      resolve({
+        success: false,
+        error: error.message,
+        executionTime: Date.now() - startTime,
+      });
+    });
+    
+    // Set timeout
+    setTimeout(() => {
+      child.kill('SIGTERM');
+      resolve({
+        success: false,
+        error: 'Command timed out',
+        executionTime: Date.now() - startTime,
+      });
+    }, timeout);
+  });
+}
+
+export function loadSkillInfo(skillName: string): SkillInfo | null {
+  // Check cache first
+  if (skillCache.has(skillName)) {
+    return skillCache.get(skillName)!;
+  }
+
+  const skillDir = join(process.cwd(), '.pi', 'skills', skillName);
+  const skillJsonPath = join(skillDir, 'SKILL.json');
+  const skillMdPath = join(skillDir, 'SKILL.md');
+
+  // Try to load from SKILL.json first
+  if (existsSync(skillJsonPath)) {
+    try {
+      const content = readFileSync(skillJsonPath, 'utf-8');
+      const skillInfo = JSON.parse(content);
+      skillCache.set(skillName, skillInfo);
+      return skillInfo;
+    } catch (error) {
+      console.error(`Failed to load skill JSON for ${skillName}:`, error);
+    }
+  }
+
+  // Fallback: try to load from SKILL.md frontmatter
+  if (existsSync(skillMdPath)) {
+    try {
+      const content = readFileSync(skillMdPath, 'utf-8');
+      const skillInfo = parseSkillMarkdown(skillName, content);
+      if (skillInfo) {
+        skillCache.set(skillName, skillInfo);
+        return skillInfo;
+      }
+    } catch (error) {
+      console.error(`Failed to load skill markdown for ${skillName}:`, error);
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Parse skill info from SKILL.md frontmatter
+ */
+function parseSkillMarkdown(skillName: string, content: string): SkillInfo | null {
+  // Parse YAML frontmatter
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch) {
+    // No frontmatter, create basic info from name
+    return {
+      name: skillName,
+      displayName: skillName,
+      description: `Skill: ${skillName}`,
+    };
+  }
+
+  const frontmatter = frontmatterMatch[1];
+  const info: SkillInfo = { name: skillName };
+
+  // Parse simple YAML key-value pairs
+  const lines = frontmatter.split('\n');
+  for (const line of lines) {
+    const match = line.match(/^(\w+):\s*(.+)$/);
+    if (match) {
+      const [, key, value] = match;
+      const cleanValue = value.replace(/^["']|["']$/g, '').trim();
+
+      switch (key) {
+        case 'name':
+          info.name = cleanValue;
+          break;
+        case 'displayName':
+        case 'display_name':
+          info.displayName = cleanValue;
+          break;
+        case 'description':
+          info.description = cleanValue;
+          break;
+        case 'version':
+          info.version = cleanValue;
+          break;
+        case 'commandPatterns':
+          // Handle array format
+          if (cleanValue.startsWith('[')) {
+            try {
+              info.commandPatterns = JSON.parse(cleanValue);
+            } catch {
+              // Ignore parse errors
+            }
+          }
+          break;
+      }
+    }
+  }
+
+  // Set defaults
+  if (!info.displayName) {
+    info.displayName = skillName;
+  }
+  if (!info.description) {
+    // Try to extract first paragraph from content
+    const bodyMatch = content.match(/---[\s\S]*?---\n\n(.+?)(?:\n\n|$)/);
+    info.description = bodyMatch ? bodyMatch[1].substring(0, 200) : `Skill: ${skillName}`;
+  }
+
+  return info;
+}
+
+export function loadSkillMarkdown(skillName: string): string | null {
+  const skillMdPath = join(process.cwd(), '.pi', 'skills', skillName, 'SKILL.md');
+  
+  if (!existsSync(skillMdPath)) {
+    return null;
+  }
+  
+  try {
+    return readFileSync(skillMdPath, 'utf-8');
+  } catch (error) {
+    console.error(`Failed to load skill markdown for ${skillName}:`, error);
+    return null;
+  }
+}
+
+export function getAvailableSkills(): SkillInfo[] {
+  const skills: SkillInfo[] = [];
+  const skillsDir = join(process.cwd(), '.pi', 'skills');
+  
+  if (!existsSync(skillsDir)) {
+    return skills;
+  }
+  
+  const entries = require('fs').readdirSync(skillsDir, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const skillInfo = loadSkillInfo(entry.name);
+      if (skillInfo) {
+        skills.push(skillInfo);
+      }
+    }
+  }
+  
+  return skills;
+}
+
+export function matchSkill(command: string): string | null {
+  const skills = getAvailableSkills();
+  
+  for (const skill of skills) {
+    if (skill.commandPatterns) {
+      for (const pattern of skill.commandPatterns) {
+        const regex = new RegExp(pattern, 'i');
+        if (regex.test(command)) {
+          return skill.name;
+        }
+      }
+    }
+  }
+  
+  return null;
+}
+
+export function clearSkillCache(): void {
+  skillCache.clear();
+}
+
+function generateTicketId(): string {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `T-${timestamp}-${random}`;
+}
+
+export interface CommandPreview {
+  command: string;
+  riskLevel: RiskLevel;
+  requiresApproval: boolean;
+  affectedResources: string[];
+  skillName?: string;
+  reason: string;
+}
+
+export function previewCommand(command: string, skillName?: string): CommandPreview {
+  const riskAssessment = estimateRisk(command, skillName);
+  const parsed = parseCommand(command);
+  const affectedResources = extractAffectedResources(parsed);
+  
+  return {
+    command,
+    riskLevel: riskAssessment.riskLevel,
+    requiresApproval: riskAssessment.requiresApproval || riskAssessment.shouldBlock,
+    affectedResources,
+    skillName,
+    reason: riskAssessment.reason,
+  };
+}

package/lib/skill-generator.ts

@@ -0,0 +1,269 @@
+/**
+ * 通用Skill生成器
+ *
+ * 根据请求生成符合通用规范的skill文件（SKILL.json + SKILL.md）
+ */
+
+import { writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import type {
+  CreateSkillRequest,
+  CreateSkillResult,
+  SkillType,
+  SkillMetadata
+} from './skill-types';
+import { installUserSkill } from './db';
+
+/**
+ * 自动检测skill类型
+ */
+export function detectSkillType(description: string): SkillType {
+  const lower = description.toLowerCase();
+
+  if (lower.includes('workflow') ||
+      lower.includes('pipeline') ||
+      lower.includes('multi-step') ||
+      lower.includes('自动化流程') ||
+      lower.includes('多步骤')) {
+    return 'workflow';
+  }
+
+  if (lower.includes('kubectl') ||
+      lower.includes('docker') ||
+      lower.includes('helm') ||
+      lower.includes('git ') ||
+      lower.includes('命令') ||
+      lower.includes('command')) {
+    return 'command';
+  }
+
+  return 'documentation';  // 默认类型
+}
+
+/**
+ * 验证skill名称格式
+ */
+export function validateSkillName(name: string): { valid: boolean; error?: string } {
+  // 必须是小写字母、数字和短横线
+  if (!/^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/.test(name)) {
+    return {
+      valid: false,
+      error: 'Skill名称必须由小写字母、数字和短横线组成，且不能以短横线开头或结尾'
+    };
+  }
+
+  // 长度限制
+  if (name.length < 2 || name.length > 50) {
+    return {
+      valid: false,
+      error: 'Skill名称长度必须在2-50个字符之间'
+    };
+  }
+
+  return { valid: true };
+}
+
+/**
+ * 生成SKILL.json内容
+ */
+export function generateSkillJson(request: CreateSkillRequest): SkillMetadata {
+  const type = request.type || detectSkillType(request.description);
+
+  const metadata: SkillMetadata = {
+    name: request.name,
+    displayName: request.displayName,
+    description: request.description,
+    version: '1.0.0',
+    author: request.author || 'user',
+    type: type,
+    createdAt: new Date().toISOString(),
+  };
+
+  // 添加命令模式（如果有）
+  if (request.commandPatterns && request.commandPatterns.length > 0) {
+    metadata.commandPatterns = request.commandPatterns;
+  }
+
+  // 添加风险配置（如果有）
+  if (request.riskConfig) {
+    metadata.riskConfig = request.riskConfig;
+  }
+
+  return metadata;
+}
+
+/**
+ * 生成SKILL.md内容
+ */
+export function generateSkillMarkdown(request: CreateSkillRequest): string {
+  const type = request.type || detectSkillType(request.description);
+
+  let content = `---
+name: ${request.name}
+description: ${request.description}
+version: 1.0.0
+author: ${request.author || 'user'}
+type: ${type}
+---
+
+# ${request.displayName}
+
+${request.description}
+
+`;
+
+  // 添加类型说明
+  content += `## 类型\n\n`;
+  switch (type) {
+    case 'documentation':
+      content += `此Skill为**知识型**，为AI提供领域知识和指令。\n\n`;
+      break;
+    case 'command':
+      content += `此Skill为**命令型**，定义了命令模式和风险配置。\n\n`;
+      break;
+    case 'workflow':
+      content += `此Skill为**工作流型**，定义了多步骤自动化操作。\n\n`;
+      break;
+    case 'hybrid':
+      content += `此Skill为**混合型**，包含多种类型的特性。\n\n`;
+      break;
+  }
+
+  // 添加知识内容
+  if (request.knowledge) {
+    content += `## 知识与指令\n\n${request.knowledge}\n\n`;
+  }
+
+  // 添加命令模式
+  if (request.commandPatterns && request.commandPatterns.length > 0) {
+    content += `## 命令模式\n\n`;
+    content += `此Skill识别以下命令模式：\n\n`;
+    request.commandPatterns.forEach(p => {
+      content += `- \`${p}\`\n`;
+    });
+    content += '\n';
+  }
+
+  // 添加示例
+  if (request.examples && request.examples.length > 0) {
+    content += `## 示例\n\n`;
+    request.examples.forEach((ex, index) => {
+      content += `### 示例 ${index + 1}: ${ex.description}\n\n`;
+      content += `\`\`\`bash\n${ex.command}\n\`\`\`\n`;
+      if (ex.riskLevel) {
+        content += `\n**风险级别:** ${ex.riskLevel}\n`;
+      }
+      content += '\n';
+    });
+  }
+
+  // 添加风险配置
+  if (request.riskConfig) {
+    content += `## 风险配置\n\n`;
+    content += `**默认风险级别:** ${request.riskConfig.default}\n\n`;
+
+    if (request.riskConfig.overrides && Object.keys(request.riskConfig.overrides).length > 0) {
+      content += `### 命令风险覆盖\n\n`;
+      content += `| 命令模式 | 风险级别 |\n|----------|----------|\n`;
+      Object.entries(request.riskConfig.overrides).forEach(([cmd, level]) => {
+        content += `| \`${cmd}\` | ${level} |\n`;
+      });
+      content += '\n';
+    }
+  }
+
+  // 添加使用说明
+  content += `## 使用方式\n\n`;
+  content += `在会话中激活此Skill后，AI将根据上述配置处理相关请求。\n`;
+
+  return content;
+}
+
+/**
+ * 创建skill主函数
+ */
+export async function createSkill(request: CreateSkillRequest): Promise<CreateSkillResult> {
+  // 根据是否有 userId 决定保存到用户目录还是系统目录
+  const baseDir = request.userId 
+    ? join(process.cwd(), 'data', 'users', request.userId, 'skills')
+    : join(process.cwd(), '.pi', 'skills');
+  
+  const skillDir = join(baseDir, request.name);
+
+  // 验证名称格式
+  const nameValidation = validateSkillName(request.name);
+  if (!nameValidation.valid) {
+    return {
+      success: false,
+      skillName: request.name,
+      skillPath: skillDir,
+      type: request.type || 'documentation',
+      files: [],
+      error: nameValidation.error,
+    };
+  }
+
+  // 检查是否已存在
+  if (existsSync(skillDir)) {
+    return {
+      success: false,
+      skillName: request.name,
+      skillPath: skillDir,
+      type: request.type || detectSkillType(request.description),
+      files: [],
+      error: `Skill '${request.name}' already exists at ${skillDir}`,
+    };
+  }
+
+  try {
+    // 创建目录
+    mkdirSync(skillDir, { recursive: true });
+
+    // 生成文件
+    const skillJson = generateSkillJson(request);
+    const skillMd = generateSkillMarkdown(request);
+
+    writeFileSync(
+      join(skillDir, 'SKILL.json'),
+      JSON.stringify(skillJson, null, 2)
+    );
+    writeFileSync(
+      join(skillDir, 'SKILL.md'),
+      skillMd
+    );
+
+    const detectedType = request.type || detectSkillType(request.description);
+
+    // 如果是用户技能，写入数据库
+    if (request.userId) {
+      try {
+        installUserSkill(request.userId, request.name, 'personal', {
+          displayName: request.displayName || request.name,
+          description: request.description,
+        });
+      } catch (dbError: any) {
+        console.error(`[skill-generator] Failed to write to database: ${dbError.message}`);
+        // 不影响返回结果，文件已创建成功
+      }
+    }
+
+    console.log(`[skill-generator] Created skill '${request.name}' (type: ${detectedType}) at ${skillDir}`);
+
+    return {
+      success: true,
+      skillName: request.name,
+      skillPath: skillDir,
+      type: detectedType,
+      files: ['SKILL.json', 'SKILL.md'],
+    };
+  } catch (error: any) {
+    return {
+      success: false,
+      skillName: request.name,
+      skillPath: skillDir,
+      type: request.type || 'documentation',
+      files: [],
+      error: `Failed to create skill: ${error.message}`,
+    };
+  }
+}