tiger-agent 0.2.0

package/src/agent/mainAgent.js

@@ -0,0 +1,406 @@
+const fs = require('fs');
+const path = require('path');
+const { chatCompletion, embedText } = require('../llmClient');
+const {
+  embeddingsEnabled,
+  allowShell,
+  ownSkillPath,
+  ownSkillUpdateHours,
+  soulPath,
+  soulUpdateHours,
+  memoryIngestEveryTurns,
+  memoryIngestMinChars
+} = require('../config');
+const { loadContextFiles } = require('./contextFiles');
+const { tools, callTool } = require('./toolbox');
+const {
+  ensureConversation,
+  addMessage,
+  getRecentMessages,
+  getMessagesForCompaction,
+  deleteMessagesUpTo,
+  addMemory,
+  getRelevantMemories,
+  getMeta,
+  setMeta,
+  recordSkillUsage
+} = require('./db');
+
+function safeJsonParse(text, fallback = {}) {
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    return fallback;
+  }
+}
+
+function renderContextFiles(files) {
+  return files
+    .map((f) => `## ${f.name}\n${f.content}`)
+    .join('\n\n');
+}
+
+async function compactConversation(conversationIdValue) {
+  const rows = getMessagesForCompaction(conversationIdValue);
+  if (!rows.length) return;
+
+  const raw = rows.map((r) => `${r.role.toUpperCase()}: ${r.content}`).join('\n');
+  const summaryMessage = await chatCompletion([
+    {
+      role: 'system',
+      content:
+        'Summarize dialogue into durable memory: user profile, goals, preferences, commitments, decisions, unresolved items.'
+    },
+    {
+      role: 'user',
+      content: raw
+    }
+  ]);
+
+  const summary = String(summaryMessage.content || '').trim();
+  if (!summary) return;
+
+  let emb = [];
+  if (embeddingsEnabled) {
+    try {
+      emb = await embedText(summary);
+    } catch (err) {
+      emb = [];
+    }
+  }
+  if (emb.length) {
+    addMemory(conversationIdValue, 'compaction', summary, emb);
+  }
+
+  const maxId = rows[rows.length - 1].id;
+  deleteMessagesUpTo(conversationIdValue, maxId);
+}
+
+async function maybeUpdateHumanFile(userText, assistantText) {
+  const files = loadContextFiles();
+  const human2 = files.find((f) => f.name === 'human2.md');
+  if (!human2) return;
+
+  const message = await chatCompletion([
+    {
+      role: 'system',
+      content:
+        'Extract long-term user profile updates. Return strict JSON: {"append": "..."} or {"append": ""}. Use short bullets.'
+    },
+    {
+      role: 'user',
+      content: `User message:\n${userText}\n\nAssistant message:\n${assistantText}`
+    }
+  ]);
+
+  const parsed = safeJsonParse(String(message.content || '{}'), {});
+  const append = String(parsed.append || '').trim();
+  if (!append) return;
+
+  const block = `\n## Update ${new Date().toISOString()}\n${append}\n`;
+  fs.appendFileSync(path.resolve(human2.full), block, 'utf8');
+}
+
+function buildSystemPrompt(contextText, memoriesText) {
+  const shellStatus = allowShell ? 'enabled' : 'disabled';
+  return [
+    'You are Tiger, a practical orchestration agent.',
+    'Use tools when needed to inspect files, execute tasks, load skills, and run sub-agents.',
+    'For OpenClaw skills, use clawhub_search and clawhub_install tools.',
+    'For greetings/small talk (e.g., "hi", "hello", "how are you"), reply directly and do not start tool/setup actions.',
+    'Only begin setup/install/search/execution steps when the user explicitly asks for those actions.',
+    `Shell tool status right now: ${shellStatus}.`,
+    'If a user asks to search the web, call run_shell first and use installed skills/commands.',
+    'Do not claim shell is disabled unless a run_shell tool call in this turn returns that error.',
+    'If tool output is incomplete, continue calling tools before final answer.',
+    'Keep answers concise and actionable.',
+    '',
+    'Always account for this identity and user profile context:',
+    contextText,
+    '',
+    memoriesText ? `Relevant compacted memory:\n${memoriesText}` : ''
+  ]
+    .filter(Boolean)
+    .join('\n');
+}
+
+function shouldRefreshFile(filePath, updateHours) {
+  try {
+    const stat = fs.statSync(filePath);
+    const maxAgeMs = updateHours * 60 * 60 * 1000;
+    return Date.now() - stat.mtimeMs >= maxAgeMs;
+  } catch (err) {
+    return true;
+  }
+}
+
+function shouldRefreshOwnSkill() {
+  return shouldRefreshFile(ownSkillPath, ownSkillUpdateHours);
+}
+
+async function maybeUpdateOwnSkillSummary(conversationIdValue) {
+  if (!shouldRefreshOwnSkill()) return;
+
+  const recent = getRecentMessages(conversationIdValue, 80);
+  const transcript = recent
+    .map((m) => `${String(m.role || '').toUpperCase()}: ${String(m.content || '')}`)
+    .join('\n');
+  const previous = fs.existsSync(ownSkillPath) ? fs.readFileSync(ownSkillPath, 'utf8') : '';
+
+  const message = await chatCompletion([
+    {
+      role: 'system',
+      content: [
+        'You maintain Tiger\'s own skill summary file.',
+        'Return concise markdown only.',
+        'Include sections:',
+        '# ownskill',
+        '## Updated',
+        '## Skills Learned',
+        '## Recent Work Summary',
+        '## Patterns Observed',
+        '## Failures & Lessons',
+        '## Successful Workflows',
+        '## Known Limits',
+        '## Next Improvements',
+        'Base updates on recent conversation work and keep it factual.'
+      ].join('\n')
+    },
+    {
+      role: 'user',
+      content: `Previous ownskill.md:\n${previous || '(empty)'}\n\nRecent work transcript:\n${transcript || '(empty)'}`
+    }
+  ]);
+
+  const next = String(message.content || '').trim();
+  if (!next) return;
+  fs.writeFileSync(path.resolve(ownSkillPath), `${next}\n`, 'utf8');
+}
+
+async function maybeUpdateSoulSummary(conversationIdValue) {
+  if (!shouldRefreshFile(soulPath, soulUpdateHours)) return;
+
+  const recent = getRecentMessages(conversationIdValue, 80);
+  const transcript = recent
+    .map((m) => `${String(m.role || '').toUpperCase()}: ${String(m.content || '')}`)
+    .join('\n');
+  const previous = fs.existsSync(soulPath) ? fs.readFileSync(soulPath, 'utf8') : '';
+  const nowIso = new Date().toISOString();
+
+  const message = await chatCompletion([
+    {
+      role: 'system',
+      content: [
+        "You maintain Tiger's soul.md: identity, principles, operating rules, and stable preferences.",
+        'Return concise markdown only.',
+        'Always include a section:',
+        '## Self-Update',
+        `- cadence_hours: ${soulUpdateHours}`,
+        `- last_updated: ${nowIso}`,
+        '- note: This is a self-maintained summary (not model training).',
+        'Keep it factual; do not include secrets/tokens; do not paste API keys.'
+      ].join('\n')
+    },
+    {
+      role: 'user',
+      content: `Previous soul.md:\n${previous || '(empty)'}\n\nRecent work transcript:\n${transcript || '(empty)'}`
+    }
+  ]);
+
+  const next = String(message.content || '').trim();
+  if (!next) return;
+  fs.writeFileSync(path.resolve(soulPath), `${next}\n`, 'utf8');
+}
+
+async function maybeIngestTurnMemory(conversationIdValue, userText, assistantText) {
+  const recent = getRecentMessages(conversationIdValue, 120);
+  const messageCount = recent.length;
+  const key = `turn_ingest_last_count:${conversationIdValue}`;
+  const lastCount = Number(getMeta(key, 0) || 0);
+  const thresholdMessages = Math.max(2, memoryIngestEveryTurns * 2);
+  const combined = `${String(userText || '').trim()}\n${String(assistantText || '').trim()}`.trim();
+  const hasPreferenceSignal =
+    /(prefer|always|never|avoid|instead|workflow|habit|schedule|every|important|priority)/i.test(combined);
+
+  if (messageCount - lastCount < thresholdMessages && combined.length < memoryIngestMinChars && !hasPreferenceSignal) {
+    return;
+  }
+
+  const transcript = recent
+    .slice(-10)
+    .map((m) => `${String(m.role || '').toUpperCase()}: ${String(m.content || '')}`)
+    .join('\n');
+
+  const message = await chatCompletion([
+    {
+      role: 'system',
+      content: [
+        'Extract one durable memory item from the recent exchange.',
+        'Return plain text only, max 2 short bullets.',
+        'Focus on user preferences, recurring workflows, or stable decisions.',
+        'Return empty string if there is no durable memory.'
+      ].join('\n')
+    },
+    {
+      role: 'user',
+      content: transcript || '(empty)'
+    }
+  ]);
+
+  const summary = String(message.content || '').trim();
+  if (!summary) return;
+
+  let emb = [];
+  if (embeddingsEnabled) {
+    try {
+      emb = await embedText(summary);
+    } catch (err) {
+      emb = [];
+    }
+  }
+  addMemory(conversationIdValue, 'turn_ingest', summary, emb);
+  setMeta(key, messageCount);
+}
+
+async function runWithTools(initialMessages) {
+  const messages = [...initialMessages];
+  const maxToolRounds = 8;
+  let lastToolError = null;
+
+  for (let i = 0; i < maxToolRounds; i += 1) {
+    const assistant = await chatCompletion(messages, { tools, tool_choice: 'auto' });
+    const rawToolCalls = Array.isArray(assistant.tool_calls) ? assistant.tool_calls : [];
+    const toolCalls = rawToolCalls.filter((tc) => tc && tc.id && tc.function && tc.function.name);
+    const assistantContent = assistant.content || '';
+    const reasoningContent = assistant.reasoning_content || '';
+
+    const assistantMsg = {
+      role: 'assistant',
+      content: assistantContent,
+      tool_calls: toolCalls
+    };
+    if (reasoningContent) {
+      assistantMsg.reasoning_content = reasoningContent;
+    }
+    messages.push(assistantMsg);
+
+    if (!toolCalls.length) {
+      if (assistantContent) return assistantContent;
+      if (lastToolError) {
+        return `⚠️ ${lastToolError.name} failed: ${lastToolError.error}`;
+      }
+      // Allow one more round if the model emitted a reasoning-only assistant turn.
+      continue;
+    }
+
+    for (const tc of toolCalls) {
+      const fn = tc.function || {};
+      const name = fn.name || '';
+      const args = safeJsonParse(fn.arguments || '{}', {});
+      let payload;
+      try {
+        payload = await callTool(name, args);
+      } catch (err) {
+        payload = { ok: false, error: err.message };
+      }
+
+      const toolFailed =
+        payload?.ok === false ||
+        payload?.status === 'error' ||
+        (typeof payload?.error === 'string' && payload.error.length > 0);
+      if (toolFailed) {
+        lastToolError = {
+          name,
+          error: String(payload?.error || 'tool execution failed')
+        };
+      }
+
+      recordSkillUsage(name, 'tool');
+      if (name === 'load_skill') {
+        const skillName = String(args.name || '').trim();
+        if (skillName) recordSkillUsage(`skill:${skillName}`, 'skill');
+      }
+
+      messages.push({
+        role: 'tool',
+        tool_call_id: tc.id,
+        content: JSON.stringify(payload)
+      });
+    }
+  }
+
+  const fallback = await chatCompletion(messages, { tools: [], tool_choice: 'none' });
+  const fallbackText = String(fallback.content || '').trim();
+  if (fallbackText) return fallbackText;
+  if (lastToolError) {
+    return `⚠️ ${lastToolError.name} failed: ${lastToolError.error}`;
+  }
+  return 'I could not produce a final answer.';
+}
+
+async function handleMessage({ platform, userId, text }) {
+  const conversationIdValue = ensureConversation(platform, userId);
+  addMessage(conversationIdValue, 'user', text);
+
+  try {
+    await compactConversation(conversationIdValue);
+  } catch (err) {
+    // Keep chat available even if compaction fails.
+  }
+
+  const contextFiles = loadContextFiles();
+  const contextText = renderContextFiles(contextFiles);
+  const recent = getRecentMessages(conversationIdValue);
+
+  let memoryText = '';
+  if (embeddingsEnabled) {
+    try {
+      const qEmb = await embedText(text);
+      const relevant = getRelevantMemories(conversationIdValue, qEmb, 6);
+      memoryText = relevant
+        .map((m) => `- (${m.source}) ${m.content}`)
+        .join('\n');
+    } catch (err) {
+      memoryText = '';
+    }
+  }
+
+  const system = buildSystemPrompt(contextText, memoryText);
+  const messages = [
+    { role: 'system', content: system },
+    ...recent.map((m) => ({ role: m.role, content: m.content }))
+  ];
+
+  const reply = (await runWithTools(messages)).trim() || 'No response generated.';
+  addMessage(conversationIdValue, 'assistant', reply);
+
+  try {
+    await maybeUpdateHumanFile(text, reply);
+  } catch (err) {
+    // Non-blocking profile update.
+  }
+
+  try {
+    await maybeUpdateOwnSkillSummary(conversationIdValue);
+  } catch (err) {
+    // Non-blocking own-skill update.
+  }
+
+  try {
+    await maybeUpdateSoulSummary(conversationIdValue);
+  } catch (err) {
+    // Non-blocking soul update.
+  }
+
+  try {
+    await maybeIngestTurnMemory(conversationIdValue, text, reply);
+  } catch (err) {
+    // Non-blocking ingestion update.
+  }
+
+  return reply;
+}
+
+module.exports = {
+  handleMessage
+};

package/src/agent/reflectionAgent.js

@@ -0,0 +1,193 @@
+const fs = require('fs');
+const path = require('path');
+const { chatCompletion, embedText } = require('../llmClient');
+const { dataDir, embeddingsEnabled } = require('../config');
+const { addMemory, getMeta, setMeta, getMessagesSince, getRecentMessagesAll } = require('./db');
+
+const REFLECTION_META_KEY = 'memory_reflection_last_run_ts';
+const MAX_MESSAGE_SCAN = 600;
+
+function nowTs() {
+  return Date.now();
+}
+
+function asIso(ts) {
+  return new Date(ts).toISOString();
+}
+
+function parseJsonMaybe(content) {
+  const text = String(content || '').trim();
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    // Continue with fenced JSON extraction fallback.
+  }
+
+  const fenced = text.match(/```json\s*([\s\S]*?)```/i);
+  if (!fenced) return null;
+  try {
+    return JSON.parse(String(fenced[1] || '').trim());
+  } catch (err) {
+    return null;
+  }
+}
+
+function normalizeItems(input, limit = 6) {
+  if (!Array.isArray(input)) return [];
+  return input
+    .map((v) => String(v || '').trim())
+    .filter(Boolean)
+    .slice(0, limit);
+}
+
+function buildTranscript(rows) {
+  return rows
+    .map((m) => {
+      const role = String(m.role || '').toUpperCase();
+      const conv = String(m.conversation_id || 'unknown');
+      const text = String(m.content || '').trim();
+      return `[${conv}] ${role}: ${text}`;
+    })
+    .join('\n');
+}
+
+function ensureHeading(markdown, heading) {
+  if (new RegExp(`^##\\s+${heading.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*$`, 'm').test(markdown)) {
+    return markdown;
+  }
+  const suffix = markdown.endsWith('\n') ? '' : '\n';
+  return `${markdown}${suffix}\n## ${heading}\n`;
+}
+
+function appendTimestampedBullets(filePath, heading, bullets, stamp) {
+  if (!bullets.length) return;
+  const full = path.resolve(filePath);
+  const existing = fs.existsSync(full) ? fs.readFileSync(full, 'utf8') : `# ${path.basename(filePath, '.md')}\n\n`;
+  const withHeading = ensureHeading(existing, heading);
+  const lines = bullets.map((line) => `- [${stamp}] ${line}`).join('\n');
+  const next = `${withHeading.trimEnd()}\n${lines}\n`;
+  fs.writeFileSync(full, next, 'utf8');
+}
+
+function appendHuman2Update(filePath, payload, stampIso) {
+  const full = path.resolve(filePath);
+  const existing = fs.existsSync(full) ? fs.readFileSync(full, 'utf8') : '# human2\n\n';
+  const lines = [];
+  if (payload.summary) lines.push(`- Summary: ${payload.summary}`);
+  for (const p of payload.patternsObserved) lines.push(`- Pattern: ${p}`);
+  for (const f of payload.failuresLessons) lines.push(`- Lesson: ${f}`);
+  for (const w of payload.successfulWorkflows) lines.push(`- Workflow: ${w}`);
+  if (!lines.length) return;
+  const block = `\n## Update ${stampIso}\n${lines.join('\n')}\n`;
+  fs.writeFileSync(full, `${existing.trimEnd()}\n${block}`, 'utf8');
+}
+
+async function generateReflection(rows, sinceIso, untilIso) {
+  const transcript = buildTranscript(rows);
+  const response = await chatCompletion([
+    {
+      role: 'system',
+      content: [
+        'You are a reflection agent that improves an assistant memory system.',
+        'Return strict JSON with this schema only:',
+        '{"summary":"","patterns_observed":[],"failures_lessons":[],"successful_workflows":[],"preference_updates":[],"what_to_do_differently":[]}',
+        'Rules:',
+        '- Keep each bullet short and factual.',
+        '- If unknown, return empty arrays.',
+        '- Do not include secrets.'
+      ].join('\n')
+    },
+    {
+      role: 'user',
+      content: [
+        `Analyze conversation data between ${sinceIso} and ${untilIso}.`,
+        'Extract actionable long-term memory updates.',
+        transcript || '(empty)'
+      ].join('\n\n')
+    }
+  ]);
+
+  const parsed = parseJsonMaybe(response.content || '');
+  if (!parsed || typeof parsed !== 'object') {
+    return null;
+  }
+
+  return {
+    summary: String(parsed.summary || '').trim(),
+    patternsObserved: normalizeItems(parsed.patterns_observed),
+    failuresLessons: normalizeItems(parsed.failures_lessons),
+    successfulWorkflows: normalizeItems(parsed.successful_workflows),
+    preferenceUpdates: normalizeItems(parsed.preference_updates),
+    whatToDoDifferently: normalizeItems(parsed.what_to_do_differently)
+  };
+}
+
+async function maybeRunReflectionCycle({ force = false } = {}) {
+  const startedAt = nowTs();
+  const lastRunTs = Number(getMeta(REFLECTION_META_KEY, 0) || 0);
+  const rows = lastRunTs
+    ? getMessagesSince(lastRunTs, MAX_MESSAGE_SCAN)
+    : getRecentMessagesAll(Math.min(MAX_MESSAGE_SCAN, 240));
+  if (!rows.length && !force) {
+    return { ok: true, skipped: true, reason: 'no_new_messages' };
+  }
+
+  const sinceIso = lastRunTs ? asIso(lastRunTs) : 'beginning';
+  const untilIso = asIso(startedAt);
+  const reflection = await generateReflection(rows, sinceIso, untilIso);
+  if (!reflection) {
+    return { ok: false, skipped: true, reason: 'invalid_reflection_json' };
+  }
+
+  const stampIso = asIso(startedAt);
+  const stampDay = stampIso.slice(0, 10);
+  const ownSkillPath = path.resolve(dataDir, 'ownskill.md');
+  const humanPath = path.resolve(dataDir, 'human.md');
+  const human2Path = path.resolve(dataDir, 'human2.md');
+  const soulPath = path.resolve(dataDir, 'soul.md');
+
+  appendTimestampedBullets(ownSkillPath, 'Patterns Observed', reflection.patternsObserved, stampDay);
+  appendTimestampedBullets(ownSkillPath, 'Failures & Lessons', reflection.failuresLessons, stampDay);
+  appendTimestampedBullets(ownSkillPath, 'Successful Workflows', reflection.successfulWorkflows, stampDay);
+
+  appendTimestampedBullets(humanPath, 'Patterns Observed', reflection.patternsObserved, stampDay);
+  appendTimestampedBullets(humanPath, 'Successful Workflows', reflection.successfulWorkflows, stampDay);
+
+  appendTimestampedBullets(soulPath, 'Patterns Observed', reflection.patternsObserved, stampDay);
+  appendTimestampedBullets(soulPath, 'Failures & Lessons', reflection.failuresLessons, stampDay);
+  appendTimestampedBullets(soulPath, 'Successful Workflows', reflection.successfulWorkflows, stampDay);
+  appendTimestampedBullets(soulPath, 'Adaptations', reflection.whatToDoDifferently, stampDay);
+
+  appendHuman2Update(human2Path, reflection, stampIso);
+
+  const memoryPayload = [
+    reflection.summary ? `Summary: ${reflection.summary}` : '',
+    ...reflection.patternsObserved.map((v) => `Pattern: ${v}`),
+    ...reflection.failuresLessons.map((v) => `Lesson: ${v}`),
+    ...reflection.successfulWorkflows.map((v) => `Workflow: ${v}`),
+    ...reflection.preferenceUpdates.map((v) => `Preference: ${v}`),
+    ...reflection.whatToDoDifferently.map((v) => `Adaptation: ${v}`)
+  ]
+    .filter(Boolean)
+    .join('\n');
+
+  if (memoryPayload) {
+    let emb = [];
+    if (embeddingsEnabled) {
+      try {
+        emb = await embedText(memoryPayload);
+      } catch (err) {
+        emb = [];
+      }
+    }
+    addMemory('global', 'self_reflection', memoryPayload, emb);
+  }
+
+  setMeta(REFLECTION_META_KEY, startedAt);
+  return { ok: true, skipped: false, at: stampIso };
+}
+
+module.exports = {
+  maybeRunReflectionCycle
+};

package/src/agent/reflectionScheduler.js

@@ -0,0 +1,21 @@
+const { reflectionUpdateHours } = require('../config');
+const { maybeRunReflectionCycle } = require('./reflectionAgent');
+
+let intervalHandle = null;
+
+function startReflectionScheduler() {
+  if (intervalHandle) return;
+
+  const everyMs = Math.max(1, Number(reflectionUpdateHours || 12)) * 60 * 60 * 1000;
+
+  // Kick one asynchronous check on startup.
+  maybeRunReflectionCycle().catch(() => {});
+
+  intervalHandle = setInterval(() => {
+    maybeRunReflectionCycle().catch(() => {});
+  }, everyMs);
+}
+
+module.exports = {
+  startReflectionScheduler
+};