fotric-claw 0.1.0

package/backend/src/agent/tools/rag.tool.ts

@@ -0,0 +1,192 @@
+import { Tool } from '@langchain/core/tools';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { FOTRIC_CONFIG } from '../../config';
+
+export interface SearchKnowledgeInput {
+  query: string;
+  topK: number;
+}
+
+interface KnowledgeDocument {
+  content: string;
+  metadata: {
+    source: string;
+    title?: string;
+  };
+}
+
+export class HybridRetrievalTool extends Tool {
+  name = 'search_knowledge_base';
+  
+  description = `Search the local knowledge base using hybrid retrieval (keyword + semantic search).
+Input should be a JSON object with a "query" field (required) and optional "topK" field.
+Example: {"query": "how to configure API settings", "topK": 5}
+Returns relevant document excerpts from the knowledge base.`;
+
+  private knowledgeDir: string;
+  private storageDir: string;
+  private documents: KnowledgeDocument[] = [];
+  private initialized = false;
+
+  constructor(options?: { knowledgeDir?: string; storageDir?: string }) {
+    super();
+    this.knowledgeDir = path.resolve(options?.knowledgeDir ?? FOTRIC_CONFIG.PATHS.KNOWLEDGE_DIR);
+    this.storageDir = path.resolve(options?.storageDir ?? FOTRIC_CONFIG.PATHS.STORAGE_DIR);
+  }
+
+  private async initialize(): Promise<void> {
+    if (this.initialized) return;
+
+    try {
+      await fs.mkdir(this.knowledgeDir, { recursive: true });
+      await this.loadDocuments();
+      this.initialized = true;
+    } catch (error) {
+      console.error('[FOTRIC-CLAW] Failed to initialize knowledge base:', error);
+    }
+  }
+
+  private async loadDocuments(): Promise<void> {
+    const extensions = ['.md', '.txt', '.json'];
+    
+    const loadDir = async (dir: string): Promise<void> => {
+      try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        
+        for (const entry of entries) {
+          const fullPath = path.join(dir, entry.name);
+          
+          if (entry.isDirectory()) {
+            await loadDir(fullPath);
+          } else if (entry.isFile() && extensions.some(ext => entry.name.endsWith(ext))) {
+            try {
+              const content = await fs.readFile(fullPath, 'utf-8');
+              this.documents.push({
+                content,
+                metadata: {
+                  source: fullPath,
+                  title: entry.name,
+                },
+              });
+            } catch {
+              console.error(`[FOTRIC-CLAW] Failed to load document: ${fullPath}`);
+            }
+          }
+        }
+      } catch {
+        console.error(`[FOTRIC-CLAW] Failed to read directory: ${dir}`);
+      }
+    };
+
+    await loadDir(this.knowledgeDir);
+  }
+
+  private tokenize(text: string): string[] {
+    return text
+      .toLowerCase()
+      .replace(/[^\w\s\u4e00-\u9fff]/g, ' ')
+      .split(/\s+/)
+      .filter(token => token.length > 1);
+  }
+
+  private bm25Score(queryTokens: string[], docTokens: string[], avgDocLength: number, k1 = 1.5, b = 0.75): number {
+    const docFreq: Record<string, number> = {};
+    const docTokenFreq: Record<string, number> = {};
+    
+    for (const token of docTokens) {
+      docTokenFreq[token] = (docTokenFreq[token] || 0) + 1;
+    }
+    
+    for (const token of queryTokens) {
+      if (docTokenFreq[token]) {
+        docFreq[token] = 1;
+      }
+    }
+
+    const N = this.documents.length;
+    const docLength = docTokens.length;
+    
+    let score = 0;
+    for (const token of queryTokens) {
+      const tf = docTokenFreq[token] || 0;
+      const df = docFreq[token] || 0;
+      const idf = Math.log((N - df + 0.5) / (df + 0.5) + 1);
+      const tfNorm = (tf * (k1 + 1)) / (tf + k1 * (1 - b + b * (docLength / avgDocLength)));
+      score += idf * tfNorm;
+    }
+
+    return score;
+  }
+
+  private simpleSemanticScore(queryTokens: string[], docTokens: string[]): number {
+    const querySet = new Set(queryTokens);
+    const docSet = new Set(docTokens);
+    
+    let intersection = 0;
+    for (const token of querySet) {
+      if (docSet.has(token)) {
+        intersection++;
+      }
+    }
+    
+    const union = querySet.size + docSet.size - intersection;
+    return union > 0 ? intersection / union : 0;
+  }
+
+  async _call(input: string): Promise<string> {
+    await this.initialize();
+
+    let parsedInput: SearchKnowledgeInput;
+    try {
+      parsedInput = JSON.parse(input);
+    } catch {
+      parsedInput = { query: input, topK: 5 };
+    }
+
+    const { query, topK = 5 } = parsedInput;
+
+    if (!query) {
+      return 'Error: Query is required.';
+    }
+
+    if (this.documents.length === 0) {
+      return 'No documents found in the knowledge base. Please add documents to the knowledge directory.';
+    }
+
+    const queryTokens = this.tokenize(query);
+    
+    const allDocTokens = this.documents.map(doc => this.tokenize(doc.content));
+    const totalLength = allDocTokens.reduce((sum, tokens) => sum + tokens.length, 0);
+    const avgDocLength = totalLength / this.documents.length;
+
+    const scored = this.documents.map((doc, index) => {
+      const docTokens = allDocTokens[index];
+      const bm25 = this.bm25Score(queryTokens, docTokens, avgDocLength);
+      const semantic = this.simpleSemanticScore(queryTokens, docTokens);
+      const combined = 0.7 * bm25 + 0.3 * semantic;
+      
+      return {
+        document: doc,
+        score: combined,
+      };
+    });
+
+    scored.sort((a, b) => b.score - a.score);
+    const topResults = scored.slice(0, topK);
+
+    if (topResults.length === 0 || topResults[0].score === 0) {
+      return 'No relevant documents found for your query.';
+    }
+
+    const results = topResults.map((result, index) => {
+      const preview = result.document.content.length > 2000
+        ? result.document.content.substring(0, 2000) + '\n...[truncated]'
+        : result.document.content;
+      
+      return `--- Document ${index + 1} ---\nSource: ${result.document.metadata.source}\nRelevance Score: ${result.score.toFixed(3)}\n\n${preview}`;
+    });
+
+    return results.join('\n\n');
+  }
+}

package/backend/src/agent/tools/shell.tool.ts

@@ -0,0 +1,65 @@
+import { Tool } from '@langchain/core/tools';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { FOTRIC_CONFIG } from '../../config';
+
+const execAsync = promisify(exec);
+
+export class ShellTool extends Tool {
+  name = 'terminal';
+  
+  description = `Execute shell commands in a sandboxed environment.
+Input should be a valid shell command string.
+The command will be executed with a timeout and safety checks.
+Returns the command output (stdout) or error message.`;
+
+  private timeout: number;
+  private blacklist: string[];
+  private cwd: string;
+
+  constructor(options?: { timeout?: number; cwd?: string }) {
+    super();
+    this.timeout = options?.timeout ?? FOTRIC_CONFIG.SHELL.TIMEOUT;
+    this.cwd = options?.cwd ?? FOTRIC_CONFIG.PATHS.ROOT_DIR;
+    this.blacklist = FOTRIC_CONFIG.SHELL.BLACKLIST;
+  }
+
+  private isCommandSafe(command: string): boolean {
+    const lowerCommand = command.toLowerCase();
+    return !this.blacklist.some(blocked => 
+      lowerCommand.includes(blocked.toLowerCase())
+    );
+  }
+
+  async _call(command: string): Promise<string> {
+    if (!this.isCommandSafe(command)) {
+      return `Error: Command blocked for safety reasons. The command contains restricted operations.`;
+    }
+
+    try {
+      const { stdout, stderr } = await execAsync(command, {
+        cwd: this.cwd,
+        timeout: this.timeout,
+        maxBuffer: 1024 * 1024 * 10,
+      });
+
+      const output = stdout || stderr || '(no output)';
+      
+      if (output.length > 10000) {
+        return output.substring(0, 10000) + '\n...[output truncated]';
+      }
+      
+      return output;
+    } catch (error) {
+      const err = error as { killed?: boolean; signal?: string; message?: string; stderr?: string; stdout?: string };
+      if (err.killed && err.signal === 'SIGTERM') {
+        return `Error: Command timed out after ${this.timeout}ms`;
+      }
+      const output = err.stderr || err.stdout || err.message || String(error);
+      if (output.length > 10000) {
+        return output.substring(0, 10000) + '\n...[output truncated]';
+      }
+      return `Error: ${output}`;
+    }
+  }
+}

package/backend/src/app.module.ts

@@ -0,0 +1,26 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { ChatModule } from './chat';
+import { AgentModule } from './agent';
+import { MemoryModule } from './memory';
+import { SessionsModule } from './sessions';
+import { FilesModule } from './files';
+import { SkillsModule } from './skills';
+import { AppConfigModule } from './config';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({
+      isGlobal: true,
+      envFilePath: '.env',
+    }),
+    SkillsModule,
+    MemoryModule,
+    AgentModule,
+    ChatModule,
+    SessionsModule,
+    FilesModule,
+    AppConfigModule,
+  ],
+})
+export class AppModule {}

package/backend/src/chat/chat.controller.ts

@@ -0,0 +1,34 @@
+import { Controller, Post, Body, Logger, Sse, MessageEvent } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { ChatService } from './chat.service';
+import { ChatDto } from './dto';
+
+@Controller('api')
+export class ChatController {
+  private readonly logger = new Logger('FOTRIC-CLAW:ChatController');
+
+  constructor(private readonly chatService: ChatService) {}
+
+  @Post('chat')
+  async chat(@Body() dto: ChatDto) {
+    const sessionId = dto.session_id || 'default';
+    this.logger.log(`Chat request from session: ${sessionId}`);
+    
+    const response = await this.chatService.chat(dto);
+    return { message: response };
+  }
+
+  @Post('chat/stream')
+  @Sse()
+  streamChat(@Body() dto: ChatDto): Observable<MessageEvent> {
+    const sessionId = dto.session_id || 'default';
+    this.logger.log(`Stream chat request from session: ${sessionId}`);
+    
+    return this.chatService.streamChat(dto).pipe(
+      map(event => ({
+        data: JSON.stringify(event),
+      } as MessageEvent)),
+    );
+  }
+}

package/backend/src/chat/chat.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { ChatController } from './chat.controller';
+import { ChatService } from './chat.service';
+import { AgentModule } from '../agent';
+
+@Module({
+  imports: [AgentModule],
+  controllers: [ChatController],
+  providers: [ChatService],
+  exports: [ChatService],
+})
+export class ChatModule {}

package/backend/src/chat/chat.service.ts

@@ -0,0 +1,52 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { Observable, Subject } from 'rxjs';
+import { AgentService } from '../agent';
+import { ChatDto, ChatStreamEvent } from './dto';
+
+@Injectable()
+export class ChatService {
+  private readonly logger = new Logger('FOTRIC-CLAW:Chat');
+
+  constructor(private readonly agentService: AgentService) {}
+
+  async chat(dto: ChatDto): Promise<string> {
+    const sessionId = dto.session_id || 'default';
+    this.logger.log(`Chat request from session: ${sessionId}`);
+    
+    return this.agentService.chat(dto.message, sessionId);
+  }
+
+  streamChat(dto: ChatDto): Observable<ChatStreamEvent> {
+    const sessionId = dto.session_id || 'default';
+    const subject = new Subject<ChatStreamEvent>();
+    
+    this.logger.log(`Stream chat request from session: ${sessionId}`);
+
+    (async () => {
+      try {
+        for await (const chunk of this.agentService.streamChat(dto.message, sessionId)) {
+          subject.next({
+            type: chunk.type,
+            content: chunk.content,
+            toolName: chunk.toolName,
+            toolArgs: chunk.toolArgs,
+          } as ChatStreamEvent);
+          
+          if (chunk.type === 'done') {
+            subject.complete();
+          }
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Stream error: ${errorMessage}`);
+        subject.next({
+          type: 'content',
+          content: `Error: ${errorMessage}`,
+        });
+        subject.complete();
+      }
+    })();
+
+    return subject.asObservable();
+  }
+}

package/backend/src/chat/dto/chat.dto.ts

@@ -0,0 +1,12 @@
+export class ChatDto {
+  message: string;
+  session_id?: string;
+  stream?: boolean;
+}
+
+export class ChatStreamEvent {
+  type: 'thought' | 'tool_call' | 'content' | 'done';
+  content: string;
+  toolName?: string;
+  toolArgs?: unknown;
+}

package/backend/src/chat/dto/index.ts

@@ -0,0 +1 @@
+export * from './chat.dto';

package/backend/src/chat/index.ts

@@ -0,0 +1,4 @@
+export * from './chat.controller';
+export * from './chat.service';
+export * from './chat.module';
+export * from './dto';

package/backend/src/config/config.controller.ts

@@ -0,0 +1,92 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { Controller, Get, Put, Body, Logger } from '@nestjs/common';
+
+interface ConfigData {
+  apiKey: string;
+  apiBaseUrl: string;
+  modelName: string;
+}
+
+@Controller('api/config')
+export class AppConfigController {
+  private readonly logger = new Logger('FOTRIC-CLAW:Config');
+  private envPath = path.resolve(process.cwd(), '.env');
+
+  @Get()
+  async getConfig(): Promise<ConfigData> {
+    return {
+      apiKey: process.env.FOTRIC_API_KEY || '',
+      apiBaseUrl: process.env.FOTRIC_API_BASE_URL || 'https://api.openai.com/v1',
+      modelName: process.env.FOTRIC_MODEL_NAME || 'gpt-4o',
+    };
+  }
+
+  @Put()
+  async updateConfig(@Body() config: ConfigData): Promise<{ success: boolean; message: string }> {
+    try {
+      const envContent = await this.readEnvFile();
+      const updatedContent = this.updateEnvContent(envContent, {
+        FOTRIC_API_KEY: config.apiKey,
+        FOTRIC_API_BASE_URL: config.apiBaseUrl,
+        FOTRIC_MODEL_NAME: config.modelName,
+      });
+      
+      await fs.writeFile(this.envPath, updatedContent, 'utf-8');
+      
+      process.env.FOTRIC_API_KEY = config.apiKey;
+      process.env.FOTRIC_API_BASE_URL = config.apiBaseUrl;
+      process.env.FOTRIC_MODEL_NAME = config.modelName;
+      
+      this.logger.log('Configuration updated successfully');
+      return { success: true, message: '配置已更新并立即生效' };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Failed to update config: ${errorMessage}`);
+      return { success: false, message: `配置更新失败: ${errorMessage}` };
+    }
+  }
+
+  private maskApiKey(key: string): string {
+    if (!key || key.length < 8) return '';
+    return key.substring(0, 4) + '****' + key.substring(key.length - 4);
+  }
+
+  private async readEnvFile(): Promise<string> {
+    try {
+      return await fs.readFile(this.envPath, 'utf-8');
+    } catch {
+      return '';
+    }
+  }
+
+  private updateEnvContent(content: string, updates: Record<string, string>): string {
+    const lines = content.split('\n');
+    const updatedKeys = new Set<string>();
+    
+    const newLines = lines.map(line => {
+      const trimmed = line.trim();
+      if (trimmed.startsWith('#') || trimmed === '') {
+        return line;
+      }
+      
+      const [key, ...valueParts] = trimmed.split('=');
+      const envKey = key?.trim();
+      
+      if (envKey && updates[envKey] !== undefined) {
+        updatedKeys.add(envKey);
+        return `${envKey}=${updates[envKey]}`;
+      }
+      
+      return line;
+    });
+    
+    for (const [key, value] of Object.entries(updates)) {
+      if (!updatedKeys.has(key) && value !== undefined) {
+        newLines.push(`${key}=${value}`);
+      }
+    }
+    
+    return newLines.join('\n');
+  }
+}

package/backend/src/config/config.module.ts

@@ -0,0 +1,7 @@
+import { Module } from '@nestjs/common';
+import { AppConfigController } from './config.controller';
+
+@Module({
+  controllers: [AppConfigController],
+})
+export class AppConfigModule {}

package/backend/src/config/constants.ts

@@ -0,0 +1,56 @@
+export const FOTRIC_CONFIG = {
+  PREFIX: '[FOTRIC-CLAW]',
+  ENV_PREFIX: 'FOTRIC_',
+  
+  get SHELL() {
+    return {
+      TIMEOUT: parseInt(process.env.FOTRIC_SHELL_TIMEOUT ?? '30000', 10),
+      BLACKLIST: [
+        'rm -rf /',
+        'rm -rf /*',
+        'sudo',
+        'chmod -R',
+        'chown -R',
+        'mkfs',
+        'dd if=',
+        '> /dev/sd',
+        ':(){:|:&};:',
+        'fork bomb',
+      ],
+    };
+  },
+  
+  get REPL() {
+    return {
+      TIMEOUT: parseInt(process.env.FOTRIC_REPL_TIMEOUT ?? '15000', 10),
+      MEMORY_LIMIT: 256 * 1024 * 1024,
+      ALLOWED_GLOBALS: ['console', 'Math', 'JSON', 'Array', 'Object', 'String', 'Number', 'Boolean', 'Date', 'RegExp', 'Error', 'Map', 'Set', 'Promise'],
+    };
+  },
+  
+  get MEMORY() {
+    return {
+      MAX_CHARS: parseInt(process.env.FOTRIC_MAX_MEMORY_CHARS ?? '20000', 10),
+      MAX_TOKENS: parseInt(process.env.FOTRIC_MAX_TOKENS ?? '128000', 10),
+    };
+  },
+  
+  get PATHS() {
+    return {
+      ROOT_DIR: process.env.FOTRIC_ROOT_DIR ?? './',
+      SKILLS_DIR: process.env.FOTRIC_SKILLS_DIR ?? './src/skills',
+      WORKSPACE_DIR: process.env.FOTRIC_WORKSPACE_DIR ?? './src/workspace',
+      SESSIONS_DIR: process.env.FOTRIC_SESSIONS_DIR ?? './src/sessions',
+      KNOWLEDGE_DIR: process.env.FOTRIC_KNOWLEDGE_DIR ?? '../knowledge',
+      STORAGE_DIR: process.env.FOTRIC_STORAGE_DIR ?? '../storage',
+    };
+  },
+  
+  get LLM() {
+    return {
+      API_KEY: process.env.FOTRIC_API_KEY ?? '',
+      API_BASE_URL: process.env.FOTRIC_API_BASE_URL ?? 'https://api.openai.com/v1',
+      MODEL_NAME: process.env.FOTRIC_MODEL_NAME ?? 'gpt-4o',
+    };
+  },
+};

package/backend/src/config/index.ts

@@ -0,0 +1,3 @@
+export * from './constants';
+export * from './config.module';
+export * from './config.controller';

package/backend/src/files/files.controller.ts

@@ -0,0 +1,87 @@
+import { Controller, Get, Post, Body, Query, BadRequestException, Logger } from '@nestjs/common';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { FOTRIC_CONFIG } from '../config';
+
+@Controller('api/files')
+export class FilesController {
+  private readonly logger = new Logger('FOTRIC-CLAW:FilesController');
+  private readonly allowedDirs: string[];
+
+  constructor() {
+    this.allowedDirs = [
+      path.resolve(FOTRIC_CONFIG.PATHS.WORKSPACE_DIR),
+      path.resolve(FOTRIC_CONFIG.PATHS.SKILLS_DIR),
+    ];
+  }
+
+  private isPathAllowed(filePath: string): boolean {
+    const resolvedPath = path.resolve(filePath);
+    return this.allowedDirs.some(allowedDir => 
+      resolvedPath.startsWith(allowedDir)
+    );
+  }
+
+  @Get()
+  async readFile(@Query('path') filePath: string) {
+    if (!filePath) {
+      throw new BadRequestException('Path is required');
+    }
+
+    if (!this.isPathAllowed(filePath)) {
+      throw new BadRequestException('Access denied. Path must be within allowed directories.');
+    }
+
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      return { content, path: filePath };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new BadRequestException(`Failed to read file: ${errorMessage}`);
+    }
+  }
+
+  @Post()
+  async writeFile(@Body() body: { path: string; content: string }) {
+    const { path: filePath, content } = body;
+
+    if (!filePath || content === undefined) {
+      throw new BadRequestException('Path and content are required');
+    }
+
+    if (!this.isPathAllowed(filePath)) {
+      throw new BadRequestException('Access denied. Path must be within allowed directories.');
+    }
+
+    try {
+      await fs.writeFile(filePath, content, 'utf-8');
+      this.logger.log(`File saved: ${filePath}`);
+      return { success: true, path: filePath };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new BadRequestException(`Failed to write file: ${errorMessage}`);
+    }
+  }
+
+  @Get('list')
+  async listFiles(@Query('dir') dir: string) {
+    const targetDir = dir || FOTRIC_CONFIG.PATHS.WORKSPACE_DIR;
+    
+    if (!this.isPathAllowed(targetDir)) {
+      throw new BadRequestException('Access denied. Directory must be within allowed directories.');
+    }
+
+    try {
+      const entries = await fs.readdir(targetDir, { withFileTypes: true });
+      const files = entries.map(entry => ({
+        name: entry.name,
+        isDirectory: entry.isDirectory(),
+        path: path.join(targetDir, entry.name),
+      }));
+      return { files, dir: targetDir };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new BadRequestException(`Failed to list directory: ${errorMessage}`);
+    }
+  }
+}

package/backend/src/files/files.module.ts

@@ -0,0 +1,7 @@
+import { Module } from '@nestjs/common';
+import { FilesController } from './files.controller';
+
+@Module({
+  controllers: [FilesController],
+})
+export class FilesModule {}

package/backend/src/files/index.ts

@@ -0,0 +1,2 @@
+export * from './files.controller';
+export * from './files.module';