fotric-claw 0.1.0

package/backend/src/main.ts

@@ -0,0 +1,21 @@
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+import { Logger } from '@nestjs/common';
+
+async function bootstrap() {
+  const logger = new Logger('FOTRIC-CLAW');
+  const app = await NestFactory.create(AppModule);
+  
+  app.enableCors({
+    origin: ['http://localhost:3000', 'http://127.0.0.1:3000'],
+    credentials: true,
+  });
+  
+  const port = process.env.PORT ?? 8002;
+  await app.listen(port);
+  
+  logger.log(`[FOTRIC-CLAW] Server is running on http://localhost:${port}`);
+  logger.log(`[FOTRIC-CLAW] API endpoint: http://localhost:${port}/api`);
+}
+
+bootstrap();

package/backend/src/memory/index.ts

@@ -0,0 +1,3 @@
+export * from './memory.types';
+export * from './memory.service';
+export * from './memory.module';

package/backend/src/memory/memory.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { MemoryService } from './memory.service';
+import { SkillsModule } from '../skills';
+
+@Module({
+  imports: [SkillsModule],
+  providers: [MemoryService],
+  exports: [MemoryService],
+})
+export class MemoryModule {}

package/backend/src/memory/memory.service.ts

@@ -0,0 +1,329 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
+import { FOTRIC_CONFIG } from '../config';
+import { SkillsService } from '../skills';
+import { MemoryFile, SystemPromptConfig, Session, SessionMessage } from './memory.types';
+
+const MEMORY_FILES = [
+  { name: 'SKILLS_SNAPSHOT', fileName: 'SKILLS_SNAPSHOT.md', order: 1, dynamic: true },
+  { name: 'SOUL', fileName: 'SOUL.md', order: 2 },
+  { name: 'IDENTITY', fileName: 'IDENTITY.md', order: 3 },
+  { name: 'USER', fileName: 'USER.md', order: 4 },
+  { name: 'AGENTS', fileName: 'AGENTS.md', order: 5 },
+  { name: 'MEMORY', fileName: 'MEMORY.md', order: 6 },
+];
+
+@Injectable()
+export class MemoryService implements OnModuleInit {
+  private readonly logger = new Logger('FOTRIC-CLAW:Memory');
+  private workspaceDir: string;
+  private sessionsDir: string;
+  private memoryCache: Map<string, string> = new Map();
+
+  constructor(private readonly skillsService: SkillsService) {
+    this.workspaceDir = path.resolve(FOTRIC_CONFIG.PATHS.WORKSPACE_DIR);
+    this.sessionsDir = path.resolve(FOTRIC_CONFIG.PATHS.SESSIONS_DIR);
+  }
+
+  async onModuleInit() {
+    await this.ensureDirectories();
+    await this.initializeDefaultFiles();
+    await this.loadMemoryFiles();
+  }
+
+  private async ensureDirectories(): Promise<void> {
+    await fs.mkdir(this.workspaceDir, { recursive: true });
+    await fs.mkdir(this.sessionsDir, { recursive: true });
+  }
+
+  private async initializeDefaultFiles(): Promise<void> {
+    const defaultFiles: Record<string, string> = {
+      'SOUL.md': `# Core Soul
+
+You are FotricCalw, a lightweight and transparent AI Agent system.
+
+## Core Values
+- Transparency: All operations are visible and explainable
+- File-first Memory: Using human-readable files for all data
+- Skills as Plugins: Extensible through markdown-based skill definitions
+
+## Behavior Guidelines
+- Always be helpful and honest
+- Explain your reasoning when asked
+- Use tools appropriately to accomplish tasks
+`,
+      'IDENTITY.md': `# Identity
+
+I am FotricCalw, an AI assistant with transparent memory and skill systems.
+
+## Capabilities
+- Execute shell commands safely
+- Run JavaScript code in a sandbox
+- Fetch and analyze web content
+- Read and write files
+- Search the knowledge base
+
+## Limitations
+- Cannot access files outside the project directory
+- Cannot execute dangerous system commands
+- Memory is limited to configured limits
+`,
+      'USER.md': `# User Profile
+
+## Preferences
+- Language: User's preferred language
+- Response style: Clear and educational
+
+## Notes
+Add user-specific information here.
+`,
+      'AGENTS.md': `# Agent Behavior Guidelines
+
+## Skill Invocation Protocol (SKILL PROTOCOL)
+
+You have access to a skills list (SKILLS_SNAPSHOT), which contains available capabilities and their definition file locations.
+
+**When you want to use a skill, you MUST follow these steps:**
+
+1. Your FIRST action is ALWAYS to use the \`read_file\` tool to read the Markdown file at the skill's \`location\` path.
+2. Carefully read the content, steps, and examples in the file.
+3. Based on the instructions in the file, combine with your built-in Core Tools (terminal, node_repl, fetch_url) to execute the specific task.
+
+**FORBIDDEN** to directly guess skill parameters or usage - you MUST read the file first!
+
+## Available Core Tools
+
+1. **terminal** - Execute shell commands in a sandboxed environment
+2. **node_repl** - Execute JavaScript code in a sandboxed Node.js environment
+3. **fetch_url** - Fetch content from URLs and extract text
+4. **read_file** - Read local file contents
+5. **search_knowledge_base** - Search the local knowledge base
+
+## Memory Operations
+
+- All conversations are stored as session files
+- Long-term memory is stored in MEMORY.md
+- You can read and update memory files as needed
+`,
+      'MEMORY.md': `# Long-term Memory
+
+This file stores persistent information that should be remembered across sessions.
+
+## Important Information
+
+(Add important information here as you interact with users)
+
+## User Preferences
+
+(Record user preferences and patterns)
+
+## Task History
+
+(Keep track of important tasks and their outcomes)
+`,
+    };
+
+    for (const [fileName, defaultContent] of Object.entries(defaultFiles)) {
+      const filePath = path.join(this.workspaceDir, fileName);
+      try {
+        await fs.access(filePath);
+      } catch {
+        await fs.writeFile(filePath, defaultContent, 'utf-8');
+        this.logger.log(`Created default file: ${fileName}`);
+      }
+    }
+  }
+
+  private async loadMemoryFiles(): Promise<void> {
+    for (const file of MEMORY_FILES) {
+      if (file.dynamic) continue;
+      
+      const filePath = path.join(this.workspaceDir, file.fileName);
+      try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        this.memoryCache.set(file.name, content);
+      } catch {
+        this.memoryCache.set(file.name, '');
+      }
+    }
+  }
+
+  async getMemoryFile(name: string): Promise<string> {
+    if (name === 'SKILLS_SNAPSHOT') {
+      return this.skillsService.generateSkillsSnapshotMarkdown();
+    }
+
+    const cached = this.memoryCache.get(name);
+    if (cached !== undefined) {
+      return cached;
+    }
+
+    const fileInfo = MEMORY_FILES.find(f => f.name === name);
+    if (!fileInfo) {
+      return '';
+    }
+
+    const filePath = path.join(this.workspaceDir, fileInfo.fileName);
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      this.memoryCache.set(name, content);
+      return content;
+    } catch {
+      return '';
+    }
+  }
+
+  async updateMemoryFile(name: string, content: string): Promise<void> {
+    const fileInfo = MEMORY_FILES.find(f => f.name === name);
+    if (!fileInfo || fileInfo.dynamic) {
+      throw new Error(`Cannot update memory file: ${name}`);
+    }
+
+    const filePath = path.join(this.workspaceDir, fileInfo.fileName);
+    await fs.writeFile(filePath, content, 'utf-8');
+    this.memoryCache.set(name, content);
+    this.logger.log(`Updated memory file: ${name}`);
+  }
+
+  async buildSystemPrompt(config: SystemPromptConfig = {}): Promise<string> {
+    const {
+      includeSkills = true,
+      includeSoul = true,
+      includeIdentity = true,
+      includeUser = true,
+      includeAgents = true,
+      includeMemory = true,
+    } = config;
+
+    const parts: string[] = [];
+
+    if (includeSkills) {
+      const skillsSnapshot = await this.getMemoryFile('SKILLS_SNAPSHOT');
+      if (skillsSnapshot) {
+        parts.push(`## Available Skills\n\n${skillsSnapshot}`);
+      }
+    }
+
+    if (includeSoul) {
+      const soul = await this.getMemoryFile('SOUL');
+      if (soul) {
+        parts.push(`## Core Soul\n\n${soul}`);
+      }
+    }
+
+    if (includeIdentity) {
+      const identity = await this.getMemoryFile('IDENTITY');
+      if (identity) {
+        parts.push(`## Identity\n\n${identity}`);
+      }
+    }
+
+    if (includeUser) {
+      const user = await this.getMemoryFile('USER');
+      if (user) {
+        parts.push(`## User Profile\n\n${user}`);
+      }
+    }
+
+    if (includeAgents) {
+      const agents = await this.getMemoryFile('AGENTS');
+      if (agents) {
+        parts.push(`## Agent Guidelines\n\n${agents}`);
+      }
+    }
+
+    if (includeMemory) {
+      const memory = await this.getMemoryFile('MEMORY');
+      if (memory) {
+        parts.push(`## Long-term Memory\n\n${memory}`);
+      }
+    }
+
+    const fullPrompt = parts.join('\n\n---\n\n');
+    
+    if (fullPrompt.length > FOTRIC_CONFIG.MEMORY.MAX_CHARS) {
+      return fullPrompt.substring(0, FOTRIC_CONFIG.MEMORY.MAX_CHARS) + '\n\n...[truncated]';
+    }
+
+    return fullPrompt;
+  }
+
+  async getSession(sessionId: string): Promise<Session | null> {
+    const sessionPath = path.join(this.sessionsDir, `${sessionId}.json`);
+    try {
+      const content = await fs.readFile(sessionPath, 'utf-8');
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+
+  async saveSession(session: Session): Promise<void> {
+    const sessionPath = path.join(this.sessionsDir, `${session.id}.json`);
+    session.updatedAt = new Date().toISOString();
+    await fs.writeFile(sessionPath, JSON.stringify(session, null, 2), 'utf-8');
+  }
+
+  async createSession(sessionId: string, name?: string): Promise<Session> {
+    const session: Session = {
+      id: sessionId,
+      name: name || `Session ${sessionId}`,
+      messages: [],
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+    await this.saveSession(session);
+    return session;
+  }
+
+  async addMessageToSession(sessionId: string, message: SessionMessage): Promise<Session> {
+    let session = await this.getSession(sessionId);
+    if (!session) {
+      session = await this.createSession(sessionId);
+    }
+    session.messages.push(message);
+    await this.saveSession(session);
+    return session;
+  }
+
+  async listSessions(): Promise<Array<{ id: string; name: string; updatedAt: string; messageCount: number }>> {
+    const files = await fs.readdir(this.sessionsDir);
+    const sessions: Array<{ id: string; name: string; updatedAt: string; messageCount: number }> = [];
+
+    for (const file of files) {
+      if (!file.endsWith('.json')) continue;
+      
+      const sessionPath = path.join(this.sessionsDir, file);
+      try {
+        const content = await fs.readFile(sessionPath, 'utf-8');
+        const session: Session = JSON.parse(content);
+        sessions.push({
+          id: session.id,
+          name: session.name,
+          updatedAt: session.updatedAt,
+          messageCount: session.messages.length,
+        });
+      } catch {
+        continue;
+      }
+    }
+
+    return sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+  }
+
+  async deleteSession(sessionId: string): Promise<boolean> {
+    const sessionPath = path.join(this.sessionsDir, `${sessionId}.json`);
+    try {
+      await fs.unlink(sessionPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async reloadMemoryFiles(): Promise<void> {
+    await this.loadMemoryFiles();
+    this.logger.log('Memory files reloaded');
+  }
+}

package/backend/src/memory/memory.types.ts

@@ -0,0 +1,38 @@
+export interface MemoryFile {
+  name: string;
+  path: string;
+  content: string;
+  order: number;
+}
+
+export interface SystemPromptConfig {
+  includeSkills?: boolean;
+  includeSoul?: boolean;
+  includeIdentity?: boolean;
+  includeUser?: boolean;
+  includeAgents?: boolean;
+  includeMemory?: boolean;
+}
+
+export interface SessionMessage {
+  role: 'user' | 'assistant' | 'system' | 'tool';
+  content: string;
+  name?: string;
+  toolCallId?: string;
+  toolCalls?: Array<{
+    id: string;
+    type: 'function';
+    function: {
+      name: string;
+      arguments: string;
+    };
+  }>;
+}
+
+export interface Session {
+  id: string;
+  name: string;
+  messages: SessionMessage[];
+  createdAt: string;
+  updatedAt: string;
+}

package/backend/src/sessions/default.json

@@ -0,0 +1,7 @@
+{
+  "id": "default",
+  "name": "Session default",
+  "messages": [],
+  "createdAt": "2026-02-27T14:30:17.725Z",
+  "updatedAt": "2026-02-27T14:30:17.726Z"
+}

package/backend/src/sessions/index.ts

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

package/backend/src/sessions/main_session.json

@@ -0,0 +1,40 @@
+{
+  "id": "main_session",
+  "name": "Session main_session",
+  "messages": [
+    {
+      "role": "user",
+      "content": "打开浏览器搜索人工智能"
+    },
+    {
+      "role": "assistant",
+      "content": "我已经为您打开了浏览器并搜索了人工智能。"
+    },
+    {
+      "role": "user",
+      "content": "今天上海天气怎么样"
+    },
+    {
+      "role": "assistant",
+      "content": "任务已执行完成。工具执行结果：{\n  \"generationtime_ms\": 0.21731853\n}"
+    },
+    {
+      "role": "user",
+      "content": "今天上海天气怎么样"
+    },
+    {
+      "role": "assistant",
+      "content": "今天上海的天气情况如下：\n\n- 天气：多云\n- 温度：16/10℃\n- 风力：<3级\n\n接下来几天的天气预报：\n- 明天：小雨转中雨，13/9℃\n- 后天：多云转阴，12/8℃\n- 周二：阴，11/7℃\n- 周三：小雨，13/7℃\n- 周四：小雨转阴，11/6℃\n- 周五：阴，12/5℃\n\n请注意保暖并携带雨具！"
+    },
+    {
+      "role": "user",
+      "content": "打开浏览器搜索人工智能"
+    },
+    {
+      "role": "assistant",
+      "content": "我已经为您打开了浏览器并搜索了人工智能。"
+    }
+  ],
+  "createdAt": "2026-02-27T14:21:52.360Z",
+  "updatedAt": "2026-02-28T02:31:05.308Z"
+}

package/backend/src/sessions/sessions.controller.ts

@@ -0,0 +1,25 @@
+import { Controller, Get, Delete, Param } from '@nestjs/common';
+import { MemoryService } from '../memory';
+
+@Controller('api/sessions')
+export class SessionsController {
+  constructor(private readonly memoryService: MemoryService) {}
+
+  @Get()
+  async listSessions() {
+    const sessions = await this.memoryService.listSessions();
+    return { sessions };
+  }
+
+  @Get(':id')
+  async getSession(@Param('id') id: string) {
+    const session = await this.memoryService.getSession(id);
+    return { session };
+  }
+
+  @Delete(':id')
+  async deleteSession(@Param('id') id: string) {
+    const success = await this.memoryService.deleteSession(id);
+    return { success };
+  }
+}

package/backend/src/sessions/sessions.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { SessionsController } from './sessions.controller';
+import { MemoryModule } from '../memory';
+
+@Module({
+  imports: [MemoryModule],
+  controllers: [SessionsController],
+})
+export class SessionsModule {}

package/backend/src/sessions/test.json

@@ -0,0 +1,16 @@
+{
+  "id": "test",
+  "name": "Session test",
+  "messages": [
+    {
+      "role": "user",
+      "content": "??"
+    },
+    {
+      "role": "assistant",
+      "content": "您好！看起来您输入了\"??\", 请问有什么我可以帮您的吗？如果您有任何问题或需要信息，请尽管告诉我！"
+    }
+  ],
+  "createdAt": "2026-02-27T14:35:06.777Z",
+  "updatedAt": "2026-02-27T14:35:09.468Z"
+}

package/backend/src/skills/browser_search/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: browser_search
+description: 调用本地浏览器打开搜索引擎进行搜索
+version: 1.1.0
+author: FotricCalw
+tags:
+  - browser
+  - search
+  - web
+---
+
+# 浏览器搜索技能
+
+此技能用于调用本地浏览器打开搜索引擎进行搜索。
+
+## 核心规则（必须遵守）
+
+1. **禁止返回命令文本给用户** - 不要告诉用户如何执行命令
+2. **必须直接调用 terminal 工具** - 立即执行，不要解释过程
+3. **执行完成后简单告知用户即可** - 例如"已为您打开浏览器搜索 xxx"
+
+## 执行流程
+
+当用户请求搜索时，你必须立即执行以下操作：
+
+### 1. 构建搜索 URL
+
+将用户的搜索词转换为 URL：
+- 空格替换为 `+`
+- 特殊字符保持原样（浏览器会自动处理）
+
+**URL 模板：**
+- 必应搜索：`https://www.bing.com/search?q={搜索词}`
+- 百度搜索：`https://www.baidu.com/s?wd={搜索词}`
+
+### 2. 立即调用 terminal 工具
+
+**必须使用 terminal 工具执行以下格式的命令：**
+
+```
+start "" "URL"
+```
+
+**调用示例：**
+
+用户说："用浏览器搜索 Python 教程"
+
+你必须立即调用 terminal 工具：
+```
+start "" "https://www.bing.com/search?q=Python+tutorial"
+```
+
+执行成功后回复："已为您打开浏览器搜索 Python 教程"
+
+## 完整示例
+
+| 用户输入 | terminal 工具执行的命令 | 回复用户 |
+|---------|------------------------|---------|
+| 用浏览器搜索 Python 教程 | `start "" "https://www.bing.com/search?q=Python+tutorial"` | 已为您打开浏览器搜索 Python 教程 |
+| 搜索今天的新闻 | `start "" "https://www.bing.com/search?q=今天+新闻"` | 已为您打开浏览器搜索今天的新闻 |
+| 百度搜索 北京天气 | `start "" "https://www.baidu.com/s?wd=北京天气"` | 已为您打开百度搜索北京天气 |
+
+## 搜索引擎选择规则
+
+- **默认使用必应搜索**
+- 当用户明确指定"百度"时使用百度搜索
+- 当搜索内容明显是中文相关时，优先使用百度
+
+## 错误处理
+
+如果 `start` 命令失败，尝试：
+```
+powershell -Command "Start-Process 'URL'"
+```
+
+## 重要提醒
+
+- 不要输出命令让用户自己执行
+- 不要解释命令的含义
+- 直接调用 terminal 工具执行
+- 执行完成后简洁回复即可

package/backend/src/skills/get_weather/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: get_weather
+description: 获取指定城市的实时天气信息
+version: 1.0.0
+author: FotricCalw
+tags:
+  - weather
+  - api
+---
+
+# 获取天气技能
+
+此技能用于获取指定城市的实时天气信息。
+
+## 使用方法
+
+1. 使用 `fetch_url` 工具访问天气 API
+2. 解析返回的 JSON 数据
+3. 向用户展示天气信息
+
+## API 端点
+
+使用 Open-Meteo 免费天气 API（无需 API Key）：
+
+```
+https://api.open-meteo.com/v1/forecast?latitude={lat}&longitude={lon}&current_weather=true
+```
+
+## 步骤
+
+### 步骤 1: 获取城市坐标
+
+首先需要获取城市的经纬度。使用 Geocoding API：
+
+```
+https://geocoding-api.open-meteo.com/v1/search?name={city_name}&count=1
+```
+
+使用 `fetch_url` 工具：
+```json
+{
+  "url": "https://geocoding-api.open-meteo.com/v1/search?name=Beijing&count=1"
+}
+```
+
+### 步骤 2: 获取天气数据
+
+从 Geocoding 响应中提取 latitude 和 longitude，然后请求天气数据：
+
+```json
+{
+  "url": "https://api.open-meteo.com/v1/forecast?latitude=39.9042&longitude=116.4074&current_weather=true"
+}
+```
+
+### 步骤 3: 格式化输出
+
+将天气数据格式化为友好的文本格式展示给用户。
+
+## 示例
+
+用户问："北京今天天气怎么样？"
+
+1. 先调用 `fetch_url` 获取北京的坐标
+2. 再调用 `fetch_url` 获取天气数据
+3. 返回格式化的天气信息
+
+## 注意事项
+
+- API 是免费的，无需 API Key
+- 温度单位默认为摄氏度
+- 返回的风速单位为 km/h

package/backend/src/skills/index.ts

@@ -0,0 +1,3 @@
+export * from './skill.types';
+export * from './skills.service';
+export * from './skills.module';

package/backend/src/skills/skill.types.ts

@@ -0,0 +1,27 @@
+export interface SkillMetadata {
+  name: string;
+  description: string;
+  version?: string;
+  author?: string;
+  tags?: string[];
+}
+
+export interface Skill {
+  name: string;
+  description: string;
+  location: string;
+  metadata: SkillMetadata;
+  content: string;
+}
+
+export interface SkillSnapshot {
+  name: string;
+  description: string;
+  location: string;
+}
+
+export interface ParsedSkill {
+  metadata: SkillMetadata;
+  content: string;
+  raw: string;
+}