tuna-agent 0.1.54 → 0.1.56

package/dist/agents/claude-code-adapter.d.ts

@@ -1,6 +1,12 @@
 import type { AgentAdapter, AgentType } from './types.js';
 import type { AgentConfig, TaskAssignment, InputResponse } from '../types/index.js';
 import type { AgentWebSocketClient } from '../daemon/ws-client.js';
+export interface LearnedRule {
+    content: string;
+    confidence: number;
+    sourceCount: number;
+    createdAt: string;
+}
 export interface AgentMetrics {
     taskCount: number;
     successCount: number;
@@ -25,6 +31,8 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
     private taskCount;
     private static readonly PATTERN_CHECK_INTERVAL;
     private metricsMap;
+    private learnedRulesMap;
+    private agentFolderMap;
     private currentAgentId;
     /** Folder basename of current agent (e.g. "co-founder"). Used as Mem0 user_id. */
     private currentAgentName;
@@ -33,6 +41,8 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
     constructor(config: AgentConfig);
     /** Get all per-agent metrics for heartbeat. */
     getMetrics(): Record<string, unknown>;
+    /** Register an agent folder path for rules parsing (called from daemon). */
+    registerAgentFolder(agentId: string, folderPath: string): void;
     checkHealth(): Promise<{
         ok: boolean;
         message: string;
@@ -58,6 +68,11 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
      * Runs every N tasks to evolve the agent's permanent knowledge.
      */
     runSelfImprovement(cwd: string): Promise<void>;
+    /**
+     * Parse "## Learned Rules" section from CLAUDE.md and store in learnedRulesMap.
+     * Rule format: `- Rule text (confidence: 0.7)`
+     */
+    private parseLearnedRules;
     /** Track task completion metrics (public for daemon resume path). */
     trackMetricsPublic(status: 'done' | 'failed', durationMs: number): void;
     /** Track task completion metrics. */

package/dist/agents/claude-code-adapter.js

@@ -16,6 +16,8 @@ export class ClaudeCodeAdapter {
     static PATTERN_CHECK_INTERVAL = 1; // Check patterns every N tasks
     // Per-agent state (one daemon handles multiple agents)
     metricsMap = new Map();
+    learnedRulesMap = new Map();
+    agentFolderMap = new Map(); // agentId -> folder path
     currentAgentId = '';
     /** Folder basename of current agent (e.g. "co-founder"). Used as Mem0 user_id. */
     currentAgentName = '';
@@ -47,12 +49,28 @@ export class ClaudeCodeAdapter {
     }
     /** Get all per-agent metrics for heartbeat. */
     getMetrics() {
+        // Re-parse rules from CLAUDE.md for all known agents
+        this.agentFolderMap.forEach((folder, agentId) => {
+            const savedId = this.currentAgentId;
+            this.currentAgentId = agentId;
+            this.parseLearnedRules(path.join(folder, 'CLAUDE.md'));
+            this.currentAgentId = savedId;
+        });
         const agentMetricsMap = {};
         this.metricsMap.forEach((m, agentId) => {
-            agentMetricsMap[agentId] = { ...m };
+            const entry = { ...m };
+            const rules = this.learnedRulesMap.get(agentId);
+            if (rules && rules.length > 0) {
+                entry.learnedRules = rules;
+            }
+            agentMetricsMap[agentId] = entry;
         });
         return { agentMetricsMap };
     }
+    /** Register an agent folder path for rules parsing (called from daemon). */
+    registerAgentFolder(agentId, folderPath) {
+        this.agentFolderMap.set(agentId, folderPath);
+    }
     async checkHealth() {
         try {
             execSync('which claude', { stdio: 'ignore' });
@@ -91,6 +109,9 @@ export class ClaudeCodeAdapter {
         this.currentAgentId = task.agentId || '';
         const defaultWorkspaceEarly = path.join(os.homedir(), 'tuna-workspace');
         this.currentAgentName = path.basename(task.repoPath || defaultWorkspaceEarly);
+        // Track agent folder for rules parsing in heartbeat
+        const cwd = task.repoPath || defaultWorkspaceEarly;
+        this.agentFolderMap.set(this.currentAgentId, cwd);
         if (task.mode !== 'tuna') {
             console.log(`[ClaudeCode] Agent Team mode — direct chat with Claude CLI`);
             ws.sendProgress(task.id, 'executing', { startedAt: new Date().toISOString() });
@@ -848,11 +869,71 @@ export class ClaudeCodeAdapter {
             this.metrics.latestLearnedRule = newPatterns[newPatterns.length - 1].rule.substring(0, 500);
             console.log(`[Self-Improve] Added ${newPatterns.length} new rules to CLAUDE.md:`);
             newPatterns.forEach(p => console.log(`[Self-Improve]   - ${p.rule}`));
+            // Sync learned rules to heartbeat metrics
+            this.parseLearnedRules(claudeMdPath);
         }
         catch (err) {
             console.warn(`[Self-Improve] Failed:`, err instanceof Error ? err.message : err);
         }
     }
+    /**
+     * Parse "## Learned Rules" section from CLAUDE.md and store in learnedRulesMap.
+     * Rule format: `- Rule text (confidence: 0.7)`
+     */
+    parseLearnedRules(claudeMdPath) {
+        try {
+            if (!fs.existsSync(claudeMdPath))
+                return;
+            const content = fs.readFileSync(claudeMdPath, 'utf-8');
+            const SECTION_HEADER = '## Learned Rules';
+            const sectionIdx = content.indexOf(SECTION_HEADER);
+            if (sectionIdx === -1)
+                return;
+            const sectionContent = content.substring(sectionIdx + SECTION_HEADER.length);
+            // End at next ## heading or end of file
+            const nextSection = sectionContent.indexOf('\n## ');
+            const rulesText = nextSection !== -1 ? sectionContent.substring(0, nextSection) : sectionContent;
+            const rules = [];
+            const ruleRegex = /^- (.+?)(?:\s*\(confidence:\s*([\d.]+)\))?$/;
+            // First pass: collect raw confidence values
+            const rawEntries = [];
+            for (const line of rulesText.split('\n')) {
+                const trimmed = line.trim();
+                if (!trimmed || !trimmed.startsWith('-'))
+                    continue;
+                const match = ruleRegex.exec(trimmed);
+                if (match) {
+                    rawEntries.push({
+                        content: match[1].trim(),
+                        rawConf: match[2] ? parseFloat(match[2]) : 0.3,
+                    });
+                }
+            }
+            // Normalize confidence: if any value > 1, treat as source_count and scale to 0-1
+            const maxConf = Math.max(...rawEntries.map(e => e.rawConf), 1);
+            const needsNormalization = maxConf > 1;
+            for (const entry of rawEntries) {
+                const sourceCount = needsNormalization ? Math.round(entry.rawConf) : 1;
+                const confidence = needsNormalization
+                    ? Math.min(Math.max(entry.rawConf / maxConf, 0.1), 1.0)
+                    : entry.rawConf;
+                rules.push({
+                    content: entry.content,
+                    confidence: Math.round(confidence * 100) / 100,
+                    sourceCount,
+                    createdAt: new Date().toISOString(),
+                });
+            }
+            if (rules.length > 0) {
+                this.learnedRulesMap.set(this.currentAgentId, rules);
+                this.metrics.rulesCount = rules.length;
+                console.log(`[Self-Improve] Parsed ${rules.length} rules from CLAUDE.md for heartbeat sync`);
+            }
+        }
+        catch (err) {
+            console.warn(`[Self-Improve] Failed to parse learned rules:`, err instanceof Error ? err.message : err);
+        }
+    }
     /** Track task completion metrics (public for daemon resume path). */
     trackMetricsPublic(status, durationMs) {
         this.trackMetrics(status, durationMs);

package/dist/daemon/index.js

@@ -264,6 +264,10 @@ export async function startDaemon(config) {
                         ? path.join(os.homedir(), rawFolder.slice(1))
                         : rawFolder;
                     console.log(`[Daemon] Rescan skills for agent ${agentId}, folder: ${folder || '(none)'}`);
+                    // Register folder for rules parsing in heartbeat
+                    if (folder && agentId && adapter.type === 'claude-code') {
+                        adapter.registerAgentFolder(agentId, folder);
+                    }
                     const folders = folder ? [folder] : [];
                     const skills = scanSkills(wsPath, folders);
                     ws.send({ action: 'agent_skills_scanned', agent_id: agentId, skills });
@@ -297,6 +301,10 @@ export async function startDaemon(config) {
                         else {
                             console.log(`[Daemon] .claude/CLAUDE.md already exists, skipping`);
                         }
+                        // Register folder for rules parsing in heartbeat
+                        if (adapter.type === 'claude-code') {
+                            adapter.registerAgentFolder(agentId, folderPath);
+                        }
                         ws.send({ action: 'agent_folder_created', agent_id: agentId, success: true });
                         console.log(`[Daemon] Agent folder created: ${folderPath}`);
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tuna-agent",
-  "version": "0.1.54",
+  "version": "0.1.56",
   "description": "Tuna Agent - Run AI coding tasks on your machine",
   "bin": {
     "tuna-agent": "dist/cli/index.js"