work-agent 0.1.0

package/lib/knowledge-tool.ts

@@ -0,0 +1,152 @@
+/**
+ * 知识保存工具
+ *
+ * 提供 save_knowledge 工具，让 AI 可以将当前会话中的有价值内容保存到知识库。
+ */
+
+import { Type } from '@sinclair/typebox';
+import type { ToolDefinition, AgentToolResult, ExtensionContext } from '@mariozechner/pi-coding-agent';
+import { createDocument, type KnowledgeType, type KnowledgeSourceType } from './db';
+
+/**
+ * 知识保存工具的参数 Schema
+ */
+const saveKnowledgeSchema = Type.Object({
+	title: Type.String({
+		description: '知识标题',
+	}),
+	content: Type.String({
+		description: '知识内容，包括问题分析、解决方案、最佳实践等',
+	}),
+	author: Type.Optional(Type.String({
+		description: '作者ID，默认为当前用户',
+	})),
+	category: Type.Optional(Type.String({
+		description: '分类，如 "运维"、"开发"、"排查" 等',
+	})),
+	tags: Type.Optional(
+		Type.Array(Type.String(), {
+			description: '标签数组，用于分类和检索',
+		})
+	),
+	type: Type.Optional(Type.String({
+		description: '知识类型: documentation(文档), troubleshooting(问题排查), best-practice(最佳实践)',
+	})),
+});
+
+/**
+ * 知识保存工具的详情类型
+ */
+interface SaveKnowledgeDetails {
+	success: boolean;
+	knowledge?: {
+		id: string;
+		title: string;
+		category?: string;
+		type?: string;
+	};
+	error?: string;
+}
+
+/**
+ * 创建知识保存工具定义
+ */
+export const saveKnowledgeTool: ToolDefinition<typeof saveKnowledgeSchema, SaveKnowledgeDetails> = {
+	name: 'save_knowledge',
+	label: 'Save Knowledge',
+	description: `将当前会话中的知识保存到知识库。
+
+使用场景：
+- 用户明确要求"记住这个"、"保存为知识"
+- 讨论了有价值的问题解决方案，值得记录
+- 总结了最佳实践或操作指南
+- 发现了常见问题及其解决方法
+
+保存的知识将在未来的会话中被激活引用，帮助更好地解决类似问题。
+
+参数说明：
+- title: 知识标题，应简洁明了
+- content: 知识内容，应包含问题描述、解决方案、步骤等详细信息
+- author: 作者ID，AI 应自动从会话上下文获取当前用户ID并传入
+- category: 可选分类，如"运维"、"开发"、"排查"等
+- tags: 可选标签数组，便于检索
+- type: 知识类型，默认为 best-practice`,
+
+	parameters: saveKnowledgeSchema,
+
+	async execute(
+		toolCallId: string,
+		params: any,
+		signal: AbortSignal | undefined,
+		onUpdate: ((result: AgentToolResult<SaveKnowledgeDetails>) => void) | undefined,
+		ctx: ExtensionContext
+	): Promise<AgentToolResult<SaveKnowledgeDetails>> {
+		try {
+			const { title, content, author, category, tags, type } = params;
+
+			// 验证类型
+			const validTypes: KnowledgeType[] = ['documentation', 'troubleshooting', 'best-practice', 'conversation-summary'];
+			const knowledgeType: KnowledgeType = validTypes.includes(type) ? type : 'best-practice';
+
+			// 创建知识条目
+			const doc = await createDocument({
+				title,
+				content,
+				category: category || '知识',
+				tags: tags || undefined,
+				author: author || 'ai-assistant',
+				type: knowledgeType,
+				sourceType: 'ai-generated' as KnowledgeSourceType,
+				isActive: true,
+			});
+
+			const result: AgentToolResult<SaveKnowledgeDetails> = {
+				content: [
+					{
+						type: 'text',
+						text: `✅ 知识已保存到知识库
+
+**标题:** ${title}
+**分类:** ${category || '知识'}
+**类型:** ${knowledgeType}
+
+此知识已可在未来的会话中被引用。`,
+					},
+				],
+				details: {
+					success: true,
+					knowledge: {
+						id: doc.id,
+						title: doc.title,
+						category: doc.category,
+						type: doc.type,
+					},
+				},
+			};
+
+			// 通知更新
+			onUpdate?.(result);
+
+			return result;
+		} catch (error: any) {
+			const errorResult: AgentToolResult<SaveKnowledgeDetails> = {
+				content: [
+					{
+						type: 'text',
+						text: `❌ 保存知识失败: ${error.message}`,
+					},
+				],
+				details: {
+					success: false,
+					error: error.message,
+				},
+			};
+
+			onUpdate?.(errorResult);
+
+			return errorResult;
+		}
+	},
+};
+
+export default saveKnowledgeTool;

package/lib/knowledge-types.ts

@@ -0,0 +1,66 @@
+/**
+ * 知识库类型定义
+ *
+ * 定义知识库系统的核心类型和接口。
+ */
+
+import type { KnowledgeType, KnowledgeSourceType } from './db';
+
+/**
+ * 知识类型描述映射
+ */
+export const KNOWLEDGE_TYPE_LABELS: Record<KnowledgeType, string> = {
+	'documentation': '文档',
+	'troubleshooting': '问题排查',
+	'best-practice': '最佳实践',
+	'conversation-summary': '会话总结',
+};
+
+/**
+ * 知识来源描述映射
+ */
+export const KNOWLEDGE_SOURCE_LABELS: Record<KnowledgeSourceType, string> = {
+	'manual': '手动创建',
+	'ai-generated': 'AI生成',
+	'conversation-summary': '会话总结',
+};
+
+/**
+ * 保存知识请求（用于 save_knowledge 工具）
+ */
+export interface SaveKnowledgeRequest {
+	title: string;
+	content: string;
+	category?: string;
+	tags?: string[];
+	type?: KnowledgeType;
+	sourceType?: KnowledgeSourceType;
+	sessionId?: string;
+}
+
+/**
+ * 知识条目（用于前端展示）
+ */
+export interface KnowledgeItem {
+	id: string;
+	title: string;
+	content: string;
+	category?: string;
+	tags?: string[];
+	author: string;
+	createdAt: string;
+	updatedAt: string;
+	type?: KnowledgeType;
+	sourceType?: KnowledgeSourceType;
+	sessionId?: string;
+	isActive: boolean;
+}
+
+/**
+ * 从会话创建知识的请求
+ */
+export interface CreateFromSessionRequest {
+	sessionId: string;
+	title?: string;
+	summary: string;
+}

package/lib/market-client.ts

@@ -0,0 +1,313 @@
+/**
+ * Market Client for AI Assistant
+ * 
+ * This client manages market operations with two modes:
+ * - Local mode (no MARKET_SERVICE_URL): Use local SQLite database
+ * - Remote mode (MARKET_SERVICE_URL configured): Use remote market service API
+ * 
+ * In remote mode, failures will throw errors instead of falling back to local
+ * to prevent data inconsistency.
+ */
+
+const MARKET_SERVICE_URL = process.env.MARKET_SERVICE_URL;
+const API_KEY = process.env.MARKET_API_KEY || 'market-dev-key-1';
+const TIMEOUT = 5000; // 5 seconds
+
+export class MarketClient {
+  private mode: 'local' | 'remote';
+  private baseUrl: string | null = null;
+  private apiKey: string | null = null;
+
+  constructor() {
+    if (MARKET_SERVICE_URL && API_KEY) {
+      this.mode = 'remote';
+      this.baseUrl = MARKET_SERVICE_URL;
+      this.apiKey = API_KEY;
+      console.log('[MarketClient] Remote mode enabled:', this.baseUrl);
+    } else {
+      this.mode = 'local';
+      console.log('[MarketClient] Local mode (no remote configured)');
+    }
+  }
+
+  /**
+   * Check if running in remote mode
+   */
+  isRemoteMode(): boolean {
+    return this.mode === 'remote';
+  }
+
+  /**
+   * Check if running in local mode
+   */
+  isLocalMode(): boolean {
+    return this.mode === 'local';
+  }
+
+  /**
+   * Check if remote service is configured (backward compatibility)
+   */
+  isRemoteEnabled(): boolean {
+    return this.mode === 'remote';
+  }
+
+  /**
+   * Get skill by ID
+   */
+  async getSkill(skillId: string): Promise<any | null> {
+    if (this.mode === 'local') {
+      const { getMarketSkillById } = await import('./market-db');
+      return getMarketSkillById(skillId);
+    }
+
+    // Remote mode: call API, throw error on failure
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), TIMEOUT);
+
+    try {
+      const response = await fetch(
+        `${this.baseUrl}/api/market/skills/${skillId}?api_key=${this.apiKey}`,
+        { signal: controller.signal }
+      );
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        throw new Error(`Market service error: ${response.status}`);
+      }
+
+      return await response.json();
+    } catch (error: any) {
+      clearTimeout(timeoutId);
+      console.error('[MarketClient] Get skill failed:', error.message);
+      throw new Error('远程市场服务不可用，请联系系统管理员');
+    }
+  }
+
+  /**
+   * Search skills
+   */
+  async searchSkills(options: {
+    search?: string;
+    status?: 'all' | 'pending' | 'approved' | 'rejected' | 'archived';
+    author?: string;
+    isOfficial?: boolean;
+    limit?: number;
+    offset?: number;
+  } = {}): Promise<{ skills: any[]; total: number }> {
+    if (this.mode === 'local') {
+      const { listMarketSkills } = await import('./market-db');
+      return listMarketSkills(options);
+    }
+
+    // Remote mode: call API, throw error on failure
+    const params = new URLSearchParams({ api_key: this.apiKey! });
+    if (options.search) params.set('search', options.search);
+    if (options.status) params.set('status', options.status);
+    if (options.author) params.set('author', options.author);
+    if (options.isOfficial !== undefined) params.set('isOfficial', options.isOfficial.toString());
+    if (options.limit) params.set('limit', options.limit.toString());
+    if (options.offset) params.set('offset', options.offset.toString());
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), TIMEOUT);
+
+    try {
+      const response = await fetch(
+        `${this.baseUrl}/api/market/skills?${params}`,
+        { signal: controller.signal }
+      );
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        throw new Error(`Market service error: ${response.status}`);
+      }
+
+      return await response.json();
+    } catch (error: any) {
+      clearTimeout(timeoutId);
+      console.error('[MarketClient] Search skills failed:', error.message);
+      throw new Error('远程市场服务不可用，请联系系统管理员');
+    }
+  }
+
+  /**
+   * Install skill
+   * Note: Skill files are still saved to user's local directory
+   */
+  async installSkill(userId: string, skillId: string): Promise<any> {
+    if (this.mode === 'local') {
+      const { addUserInstalledSkill } = await import('./market-db');
+      addUserInstalledSkill(userId, skillId);
+      const skill = await this.getSkill(skillId);
+      return skill;
+    }
+
+    // Remote mode: download from market service
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), TIMEOUT * 2);
+
+    try {
+      const response = await fetch(
+        `${this.baseUrl}/api/market/skills/${skillId}/download?api_key=${this.apiKey}`,
+        { signal: controller.signal }
+      );
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        throw new Error('Failed to download skill');
+      }
+
+      // Save to user directory
+      const { join } = await import('path');
+      const { writeFileSync, mkdirSync, existsSync } = await import('fs');
+      
+      const userSkillDir = join(process.cwd(), 'data', 'skills', 'users', userId);
+      
+      if (!existsSync(userSkillDir)) {
+        mkdirSync(userSkillDir, { recursive: true });
+      }
+      
+      const zipPath = join(userSkillDir, `${skillId}.zip`);
+      
+      const arrayBuffer = await response.arrayBuffer();
+      writeFileSync(zipPath, Buffer.from(arrayBuffer));
+      
+      const { unpackSkillFromZip } = await import('./zip-tool');
+      unpackSkillFromZip(zipPath, userSkillDir);
+
+      const { addUserInstalledSkill } = await import('./market-db');
+      addUserInstalledSkill(userId, skillId);
+
+      return await this.getSkill(skillId);
+    } catch (error: any) {
+      clearTimeout(timeoutId);
+      console.error('[MarketClient] Install skill failed:', error.message);
+      throw new Error('安装技能失败，请稍后重试或联系管理员');
+    }
+  }
+
+  /**
+   * Get knowledge list from market
+   */
+  async getKnowledge(options: {
+    category?: string;
+    search?: string;
+    limit?: number;
+  } = {}): Promise<any[]> {
+    if (this.mode === 'local') {
+      // Local mode: query local published knowledge
+      const { getMarketKnowledge } = await import('./db');
+      const result = getMarketKnowledge(options);
+      return Array.isArray(result) ? result : result.documents || [];
+    }
+
+    // Remote mode: call API, throw error on failure
+    const params = new URLSearchParams({ api_key: this.apiKey! });
+    if (options.category) params.set('category', options.category);
+    if (options.search) params.set('search', options.search);
+    if (options.limit) params.set('limit', options.limit.toString());
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), TIMEOUT);
+
+    try {
+      const response = await fetch(
+        `${this.baseUrl}/api/market/knowledge?${params}`,
+        { signal: controller.signal }
+      );
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        throw new Error(`Market service error: ${response.status}`);
+      }
+
+      const data = await response.json();
+      return Array.isArray(data) ? data : data.knowledge || data.documents || [];
+    } catch (error: any) {
+      clearTimeout(timeoutId);
+      console.error('[MarketClient] Get knowledge failed:', error.message);
+      throw new Error('远程市场服务不可用，请联系系统管理员');
+    }
+  }
+
+  /**
+   * Publish knowledge to market
+   */
+  async publishKnowledge(knowledgeId: string, author: string): Promise<any | null> {
+    if (this.mode === 'local') {
+      // Local mode: update local market_status
+      const { publishKnowledgeToMarket } = await import('./db');
+      return publishKnowledgeToMarket(knowledgeId, author);
+    }
+
+    // Remote mode: push to remote market
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), TIMEOUT);
+
+    try {
+      // Get local knowledge content first
+      const { getDocument, updateDocument } = await import('./db');
+      const doc = getDocument(knowledgeId);
+      
+      if (!doc) {
+        throw new Error('知识不存在');
+      }
+
+      // Push to remote market with full content
+      const response = await fetch(
+        `${this.baseUrl}/api/market/knowledge`,
+        {
+          method: 'POST',
+          signal: controller.signal,
+          headers: {
+            'X-API-Key': this.apiKey!,
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            id: knowledgeId,
+            title: doc.title,
+            content: doc.content,
+            category: doc.category,
+            tags: doc.tags,
+            author,
+          }),
+        }
+      );
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        throw new Error(`Publish failed: ${response.status}`);
+      }
+
+      const data = await response.json();
+      console.log('[MarketClient] Published knowledge to remote market:', knowledgeId);
+      
+      // Update local market_status to indicate published
+      await updateDocument(knowledgeId, { marketStatus: 'published' } as any);
+      
+      return data.knowledge || data;
+    } catch (error: any) {
+      clearTimeout(timeoutId);
+      console.error('[MarketClient] Publish to remote failed:', error.message);
+      throw new Error('发布到远程市场失败，请稍后重试或联系管理员');
+    }
+  }
+}
+
+// Singleton instance
+let client: MarketClient | null = null;
+
+/**
+ * Get market client instance
+ */
+export function getMarketClient(): MarketClient {
+  if (!client) {
+    client = new MarketClient();
+  }
+  return client;
+}