work-agent 0.1.0

package/lib/ticket-tool.ts

@@ -0,0 +1,246 @@
+/**
+ * 工单创建工具
+ *
+ * 提供 create_ticket 工具，让 AI 可以创建需要审批的工单。
+ */
+
+import { Type } from '@sinclair/typebox';
+import type { ToolDefinition, AgentToolResult, ExtensionContext } from '@mariozechner/pi-coding-agent';
+import { createTicket } from './db';
+import { estimateRiskLevel } from './dangerous-commands';
+import { getCurrentSessionId } from './pi-session';
+
+/**
+ * 工单创建工具的参数 Schema
+ */
+const createTicketSchema = Type.Object({
+  command: Type.String({
+    description: '要执行的命令',
+  }),
+  title: Type.Optional(Type.String({
+    description: '工单标题（可选，默认根据命令生成）',
+  })),
+  description: Type.Optional(Type.String({
+    description: '工单描述（可选）',
+  })),
+  createdBy: Type.Optional(Type.String({
+    description: '创建者ID，AI应自动从会话上下文获取当前用户ID并传入',
+  })),
+  skillName: Type.Optional(Type.String({
+    description: '关联的 Skill 名称（可选）',
+  })),
+  affectedResources: Type.Optional(Type.Array(Type.String(), {
+    description: '受影响的资源列表（可选）',
+  })),
+});
+
+/**
+ * 工单创建工具的详情类型
+ */
+interface CreateTicketDetails {
+  success: boolean;
+  ticket?: {
+    id: string;
+    title: string;
+    type: string;
+    status: string;
+    priority: string;
+    command: string;
+    riskLevel: string;
+    description?: string;
+  };
+  error?: string;
+}
+
+/**
+ * 创建工单工具定义
+ */
+export const createTicketTool: ToolDefinition<typeof createTicketSchema, CreateTicketDetails> = {
+  name: 'create_ticket',
+  label: 'Create Ticket',
+  description: `创建一个需要审批的命令执行工单。
+
+当需要执行危险或重要操作时，使用此工具创建工单。工单需要人工审批后才能执行。
+
+危险命令示例：
+- rm -rf 删除文件
+- 系统关机/重启命令
+- 数据库删除/修改操作
+- 文件系统格式化
+
+安全命令（不需要审批）：
+- ls/cat/head/tail 等文件查看
+- git status/log 等只读操作
+- echo/printf 等输出命令
+
+注意：createdBy 参数必须传入当前用户ID，AI应自动从会话上下文获取。`,
+
+  parameters: createTicketSchema,
+
+  async execute(
+    toolCallId: string,
+    params: any,
+    signal: AbortSignal | undefined,
+    onUpdate: ((result: AgentToolResult<CreateTicketDetails>) => void) | undefined,
+    ctx: ExtensionContext
+  ): Promise<AgentToolResult<CreateTicketDetails>> {
+    try {
+      const { command, title, description, createdBy, skillName, affectedResources } = params;
+
+      // 评估命令风险等级
+      const riskLevel = estimateRiskLevel(command);
+
+      // 生成默认标题
+      const ticketTitle = title || generateDefaultTitle(command, skillName);
+
+      // 生成默认描述
+      const ticketDescription = description || generateDefaultDescription(command, skillName, riskLevel);
+
+      // 创建工单
+      const ticket = await createTicket({
+        type: 'bash-execute',
+        title: ticketTitle,
+        description: ticketDescription,
+        status: 'pending',
+        priority: riskLevel as any,
+        command,
+        commandType: detectCommandType(command),
+        skillName,
+        riskLevel: riskLevel as any,
+        affectedResources: affectedResources || extractAffectedResources(command),
+        approvals: [],
+        createdBy: createdBy || 'ai-assistant',
+        aiSessionId: getCurrentSessionId() || undefined,
+        aiGenerated: true,
+      });
+
+      const result: AgentToolResult<CreateTicketDetails> = {
+        content: [
+          {
+            type: 'text',
+            text: `✅ 工单已创建
+
+**工单 ID:** ${ticket.id}
+**标题:** ${ticket.title}
+**风险等级:** ${ticket.riskLevel}
+**状态:** ${ticket.status}
+
+此工单需要审批后才能执行。请在工单管理界面查看和审批。`,
+          },
+        ],
+        details: {
+          success: true,
+          ticket: {
+            id: ticket.id,
+            title: ticket.title,
+            type: ticket.type,
+            status: ticket.status,
+            priority: ticket.priority,
+            command: ticket.command || '',
+            riskLevel: ticket.riskLevel,
+            description: ticket.description,
+          },
+        },
+      };
+
+      // 通知更新
+      onUpdate?.(result);
+
+      return result;
+    } catch (error: any) {
+      const errorResult: AgentToolResult<CreateTicketDetails> = {
+        content: [
+          {
+            type: 'text',
+            text: `❌ 创建工单失败: ${error.message}`,
+          },
+        ],
+        details: {
+          success: false,
+          error: error.message,
+        },
+      };
+
+      onUpdate?.(errorResult);
+
+      return errorResult;
+    }
+  },
+};
+
+/**
+ * 生成默认工单标题
+ */
+function generateDefaultTitle(command: string, skillName?: string): string {
+  // 截取命令的前 50 个字符
+  const cmdPreview = command.split(' ').slice(0, 4).join(' ');
+  const truncated = cmdPreview.length > 50 ? cmdPreview.substring(0, 50) + '...' : cmdPreview;
+
+  if (skillName) {
+    return `[${skillName}] ${truncated}`;
+  }
+
+  return `执行命令: ${truncated}`;
+}
+
+/**
+ * 生成默认工单描述
+ */
+function generateDefaultDescription(command: string, skillName?: string, riskLevel?: string): string {
+  let desc = `## 命令详情\n\n\`\`\`bash\n${command}\n\`\`\`\n\n`;
+
+  if (skillName) {
+    desc += `**关联 Skill:** ${skillName}\n\n`;
+  }
+
+  desc += `**风险等级:** ${riskLevel || 'medium'}\n\n---\n\n此工单由 AI 助手创建，需要审批后才能执行。`;
+
+  return desc;
+}
+
+/**
+ * 检测命令类型
+ */
+function detectCommandType(command: string): string {
+  const trimmed = command.toLowerCase().trim();
+
+  if (trimmed.startsWith('kubectl')) return 'kubectl';
+  if (trimmed.startsWith('docker')) return 'docker';
+  if (trimmed.startsWith('helm')) return 'helm';
+  if (trimmed.startsWith('git')) return 'git';
+  if (trimmed.startsWith('npm') || trimmed.startsWith('yarn')) return 'package-manager';
+  if (trimmed.startsWith('curl') || trimmed.startsWith('wget')) return 'network';
+
+  return 'bash';
+}
+
+/**
+ * 从命令中提取受影响的资源
+ */
+function extractAffectedResources(command: string): string[] | undefined {
+  const resources: string[] = [];
+
+  // 提取 kubectl 资源
+  const kubectlMatch = command.match(/kubectl\s+.*?\s+(\S+)(?:\s+(-n|--namespace)\s+(\S+))?/);
+  if (kubectlMatch) {
+    const resource = kubectlMatch[1];
+    if (!resource.startsWith('-')) {
+      resources.push(resource);
+    }
+  }
+
+  // 提取文件路径
+  const fileMatches = command.match(/(?:^|\s)(\/[\w\/.-]+)/g);
+  if (fileMatches) {
+    for (const match of fileMatches) {
+      const path = match.trim();
+      if (path.length > 1 && !path.startsWith('/dev/')) {
+        resources.push(path);
+      }
+    }
+  }
+
+  return resources.length > 0 ? resources : undefined;
+}
+
+export default createTicketTool;

package/lib/user-skill-types.ts

@@ -0,0 +1,30 @@
+/**
+ * 用户私有技能类型定义
+ */
+
+export interface UserSkill {
+  name: string;
+  displayName: string;
+  description: string;
+  version: string;
+  author: string;           // 用户ID
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface CreateUserSkillRequest {
+  name: string;
+  displayName: string;
+  description: string;
+  content: string;          // SKILL.md 内容
+  version?: string;
+  riskConfig?: any;
+}
+
+export interface UpdateUserSkillRequest {
+  displayName?: string;
+  description?: string;
+  content?: string;
+  version?: string;
+  riskConfig?: any;
+}

package/lib/user-skills.ts

@@ -0,0 +1,362 @@
+/**
+ * 用户私有技能管理工具
+ */
+
+import { mkdirSync, writeFileSync, readFileSync, existsSync, unlinkSync, rmdirSync, readdirSync } from 'fs';
+import { join } from 'path';
+import type { UserSkill, CreateUserSkillRequest, UpdateUserSkillRequest } from './user-skill-types';
+import { getDb } from './db';
+
+const USER_SKILLS_BASE = join(process.cwd(), 'data', 'users');
+
+/**
+ * 确保用户技能目录存在
+ */
+function ensureUserSkillsDir(userId: string): string {
+  const userDir = join(USER_SKILLS_BASE, userId, 'skills');
+  if (!existsSync(userDir)) {
+    mkdirSync(userDir, { recursive: true });
+  }
+  return userDir;
+}
+
+/**
+ * 同步结果
+ */
+export interface SyncResult {
+  added: string[];      // 新增到数据库的技能
+  removed: string[];    // 从数据库删除的记录
+  unchanged: string[];  // 无变化的技能
+}
+
+/**
+ * 同步用户技能到数据库
+ * - 扫描文件系统中的技能目录
+ * - 补全缺失的数据库记录
+ * - 清理已删除技能的数据库记录
+ * 
+ * @param userId 用户ID
+ * @returns 同步结果
+ */
+export function syncUserSkills(userId: string): SyncResult {
+  const db = getDb();
+  const userDir = join(USER_SKILLS_BASE, userId, 'skills');
+  const result: SyncResult = { added: [], removed: [], unchanged: [] };
+
+  // 1. 获取文件系统中的技能
+  const fsSkills = new Map<string, { dirName: string; skillData: any }>();
+  if (existsSync(userDir)) {
+    const entries = readdirSync(userDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      
+      const skillDir = join(userDir, entry.name);
+      const jsonPath = join(skillDir, 'SKILL.json');
+      
+      if (!existsSync(jsonPath)) continue;
+      
+      try {
+        const jsonContent = readFileSync(jsonPath, 'utf-8');
+        const skillData = JSON.parse(jsonContent);
+        const skillName = skillData.name || entry.name;
+        fsSkills.set(skillName, { dirName: entry.name, skillData });
+      } catch (error) {
+        console.error(`[syncUserSkills] Failed to read ${entry.name}:`, error);
+      }
+    }
+  }
+
+  // 2. 获取数据库中的技能
+  const dbSkills = new Map<string, { id: string; skillName: string; dirName: string }>();
+  const rows = db.prepare('SELECT id, skill_name, dir_name FROM user_skills WHERE user_id = ?').all(userId) as any[];
+  for (const row of rows) {
+    dbSkills.set(row.skill_name, { id: row.id, skillName: row.skill_name, dirName: row.dir_name });
+  }
+
+  // 3. 对比差异
+  const now = new Date().toISOString();
+
+  // 文件存在但数据库无记录 → 插入
+  for (const [skillName, { dirName, skillData }] of fsSkills) {
+    if (!dbSkills.has(skillName)) {
+      const skillId = `us-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+      db.prepare(`
+        INSERT INTO user_skills (id, user_id, skill_name, dir_name, source, use_count, installed_at)
+        VALUES (?, ?, ?, ?, 'personal', 0, ?)
+      `).run(skillId, userId, skillName, dirName, now);
+      result.added.push(skillName);
+      console.log(`[syncUserSkills] Added: ${skillName}`);
+    } else {
+      result.unchanged.push(skillName);
+    }
+  }
+
+  // 数据库有记录但文件不存在 → 删除
+  for (const [skillName, { id }] of dbSkills) {
+    if (!fsSkills.has(skillName)) {
+      db.prepare('DELETE FROM user_skills WHERE id = ?').run(id);
+      result.removed.push(skillName);
+      console.log(`[syncUserSkills] Removed: ${skillName}`);
+    }
+  }
+
+  if (result.added.length > 0 || result.removed.length > 0) {
+    console.log(`[syncUserSkills] Synced for ${userId}: +${result.added.length}, -${result.removed.length}`);
+  }
+
+  return result;
+}
+
+/**
+ * 创建用户私有技能
+ */
+export function createUserSkill(userId: string, request: CreateUserSkillRequest): UserSkill {
+  const db = getDb();
+  
+  // 目录名直接使用 name（不再拼音转换）
+  const skillName = request.name;
+  const userDir = ensureUserSkillsDir(userId);
+  const skillDir = join(userDir, skillName);
+
+  // 检查是否已存在
+  if (existsSync(skillDir)) {
+    throw new Error(`Skill "${skillName}" already exists`);
+  }
+
+  // 创建技能目录
+  mkdirSync(skillDir, { recursive: true });
+
+  const now = new Date().toISOString();
+  const version = request.version || '1.0.0';
+
+  // 写入 SKILL.json
+  const skillJson = {
+    name: skillName,
+    displayName: request.displayName || skillName,
+    description: request.description,
+    version,
+    author: userId,
+    type: 'user',
+    createdAt: now,
+    updatedAt: now,
+    ...(request.riskConfig && { riskConfig: request.riskConfig }),
+  };
+
+  writeFileSync(join(skillDir, 'SKILL.json'), JSON.stringify(skillJson, null, 2));
+
+  // 写入 SKILL.md（符合 agentskills.io 规范，包含 YAML frontmatter）
+  const skillMdWithFrontmatter = `---
+name: ${skillName}
+description: ${request.description}
+---
+
+${request.content}`;
+  writeFileSync(join(skillDir, 'SKILL.md'), skillMdWithFrontmatter);
+
+  // 保存到数据库
+  const skillId = `us-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+  db.prepare(`
+    INSERT INTO user_skills (id, user_id, skill_name, dir_name, source, use_count, installed_at)
+    VALUES (?, ?, ?, ?, 'personal', 0, ?)
+  `).run(skillId, userId, skillName, skillName, now);
+
+  return {
+    name: skillName,
+    displayName: request.displayName || skillName,
+    description: request.description,
+    version,
+    author: userId,
+    createdAt: now,
+    updatedAt: now,
+  };
+}
+
+/**
+ * 获取用户私有技能列表
+ */
+export function listUserSkills(userId: string): UserSkill[] {
+  const userDir = join(USER_SKILLS_BASE, userId, 'skills');
+
+  if (!existsSync(userDir)) {
+    return [];
+  }
+
+  const skills: UserSkill[] = [];
+  const entries = readdirSync(userDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+
+    const skillDir = join(userDir, entry.name);
+    const jsonPath = join(skillDir, 'SKILL.json');
+
+    if (!existsSync(jsonPath)) continue;
+
+    try {
+      const jsonContent = readFileSync(jsonPath, 'utf-8');
+      const skillData = JSON.parse(jsonContent);
+
+      skills.push({
+        name: skillData.name,
+        displayName: skillData.displayName,
+        description: skillData.description,
+        version: skillData.version,
+        author: skillData.author,
+        createdAt: skillData.createdAt,
+        updatedAt: skillData.updatedAt,
+      });
+    } catch (error) {
+      console.error(`Failed to load skill metadata for ${entry.name}:`, error);
+    }
+  }
+
+  return skills;
+}
+
+/**
+ * 获取用户私有技能详情
+ */
+export function getUserSkill(userId: string, skillName: string): UserSkill | null {
+  const skillDir = join(USER_SKILLS_BASE, userId, 'skills', skillName);
+  const jsonPath = join(skillDir, 'SKILL.json');
+
+  if (!existsSync(jsonPath)) {
+    return null;
+  }
+
+  try {
+    const jsonContent = readFileSync(jsonPath, 'utf-8');
+    const skillData = JSON.parse(jsonContent);
+
+    return {
+      name: skillData.name,
+      displayName: skillData.displayName,
+      description: skillData.description,
+      version: skillData.version,
+      author: skillData.author,
+      createdAt: skillData.createdAt,
+      updatedAt: skillData.updatedAt,
+    };
+  } catch (error) {
+    console.error(`Failed to load skill ${skillName}:`, error);
+    return null;
+  }
+}
+
+/**
+ * 获取用户技能内容 (SKILL.md)
+ */
+export function getUserSkillContent(userId: string, skillName: string): string | null {
+  const skillDir = join(USER_SKILLS_BASE, userId, 'skills', skillName);
+  const mdPath = join(skillDir, 'SKILL.md');
+
+  if (!existsSync(mdPath)) {
+    return null;
+  }
+
+  try {
+    return readFileSync(mdPath, 'utf-8');
+  } catch (error) {
+    console.error(`Failed to load skill content for ${skillName}:`, error);
+    return null;
+  }
+}
+
+/**
+ * 更新用户私有技能
+ */
+export function updateUserSkill(userId: string, skillName: string, request: UpdateUserSkillRequest): UserSkill | null {
+  const skillDir = join(USER_SKILLS_BASE, userId, 'skills', skillName);
+  const jsonPath = join(skillDir, 'SKILL.json');
+
+  if (!existsSync(jsonPath)) {
+    return null;
+  }
+
+  try {
+    // 读取现有数据
+    const jsonContent = readFileSync(jsonPath, 'utf-8');
+    const skillData = JSON.parse(jsonContent);
+
+    // 验证所有权
+    if (skillData.author !== userId) {
+      throw new Error('You do not have permission to update this skill');
+    }
+
+    // 更新字段
+    const now = new Date().toISOString();
+    if (request.displayName !== undefined) skillData.displayName = request.displayName;
+    if (request.description !== undefined) skillData.description = request.description;
+    if (request.version !== undefined) skillData.version = request.version;
+    if (request.riskConfig !== undefined) skillData.riskConfig = request.riskConfig;
+    skillData.updatedAt = now;
+
+    // 写回 JSON
+    writeFileSync(jsonPath, JSON.stringify(skillData, null, 2));
+
+    // 更新内容（如果提供）
+    if (request.content !== undefined) {
+      const mdPath = join(skillDir, 'SKILL.md');
+      // 符合 agentskills.io 规范，包含 YAML frontmatter
+      const skillMdWithFrontmatter = `---
+name: ${skillData.name}
+description: ${skillData.description}
+---
+
+${request.content}`;
+      writeFileSync(mdPath, skillMdWithFrontmatter);
+    }
+
+    return {
+      name: skillData.name,
+      displayName: skillData.displayName,
+      description: skillData.description,
+      version: skillData.version,
+      author: skillData.author,
+      createdAt: skillData.createdAt,
+      updatedAt: now,
+    };
+  } catch (error: any) {
+    console.error(`Failed to update skill ${skillName}:`, error);
+    throw error;
+  }
+}
+
+/**
+ * 删除用户私有技能
+ */
+export function deleteUserSkill(userId: string, skillName: string): boolean {
+  const db = getDb();
+  const skillDir = join(USER_SKILLS_BASE, userId, 'skills', skillName);
+
+  // 删除数据库记录
+  db.prepare('DELETE FROM user_skills WHERE user_id = ? AND skill_name = ?').run(userId, skillName);
+
+  if (!existsSync(skillDir)) {
+    return true; // 数据库已删除，目录不存在也算成功
+  }
+
+  try {
+    // 验证所有权
+    const jsonPath = join(skillDir, 'SKILL.json');
+    const jsonContent = readFileSync(jsonPath, 'utf-8');
+    const skillData = JSON.parse(jsonContent);
+
+    if (skillData.author !== userId) {
+      throw new Error('You do not have permission to delete this skill');
+    }
+
+    // 删除文件
+    const mdPath = join(skillDir, 'SKILL.md');
+    if (existsSync(mdPath)) unlinkSync(mdPath);
+    unlinkSync(jsonPath);
+
+    // 删除目录
+    rmdirSync(skillDir);
+
+    return true;
+  } catch (error: any) {
+    console.error(`Failed to delete skill ${skillName}:`, error);
+    throw error;
+  }
+}

package/lib/utils.ts

@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+export function cn(...inputs: ClassValue[]) {
+	return twMerge(clsx(inputs));
+}