@geminilight/mindos 0.5.63 → 0.5.65

package/app/lib/agent/log.ts

@@ -1,9 +1,9 @@
 import fs from 'fs';
 import path from 'path';
 import { getMindRoot } from '@/lib/fs';
+import { appendAgentAuditEvent } from '@/lib/core/agent-audit-log';
 
-const LOG_FILE = '.agent-log.json';
-const MAX_SIZE = 500 * 1024; // 500KB
+const LEGACY_LOG_FILE = '.agent-log.json';
 
 interface AgentOpEntry {
   ts: string;
@@ -22,23 +22,20 @@ interface AgentOpEntry {
 export function logAgentOp(entry: AgentOpEntry): void {
   try {
     const root = getMindRoot();
-    const logPath = path.join(root, LOG_FILE);
-
-    const line = JSON.stringify(entry) + '\n';
-
-    // Check size and truncate if needed
-    if (fs.existsSync(logPath)) {
-      const stat = fs.statSync(logPath);
-      if (stat.size > MAX_SIZE) {
-        const content = fs.readFileSync(logPath, 'utf-8');
-        const lines = content.trimEnd().split('\n');
-        // Keep the newer half
-        const kept = lines.slice(Math.floor(lines.length / 2));
-        fs.writeFileSync(logPath, kept.join('\n') + '\n');
-      }
+    appendAgentAuditEvent(root, {
+      ts: entry.ts,
+      tool: entry.tool,
+      params: entry.params,
+      result: entry.result,
+      message: entry.message,
+      durationMs: entry.durationMs,
+    });
+    // Best-effort cleanup of legacy JSONL path.
+    try {
+      fs.rmSync(path.join(root, LEGACY_LOG_FILE), { force: true });
+    } catch {
+      // ignore
     }
-
-    fs.appendFileSync(logPath, line);
   } catch {
     // Logging should never break tool execution
   }

package/app/lib/agent/stream-consumer.ts

@@ -31,6 +31,8 @@ export async function consumeUIMessageStream(
   let currentTextId: string | null = null;
   let currentReasoningPart: ReasoningPart | null = null;
 
+  const startedAt = Date.now();
+
   /** Build an immutable Message snapshot from current parts */
   function buildMessage(): Message {
     const clonedParts: MessagePart[] = parts.map(p => {
@@ -47,6 +49,7 @@ export async function consumeUIMessageStream(
       role: 'assistant',
       content: textContent,
       parts: clonedParts,
+      timestamp: startedAt,
     };
   }
 

package/app/lib/agent/to-agent-messages.ts

@@ -24,11 +24,13 @@ export function toAgentMessages(messages: FrontendMessage[]): AgentMessage[] {
   const result: AgentMessage[] = [];
 
   for (const msg of messages) {
+    const timestamp = msg.timestamp ?? Date.now();
+
     if (msg.role === 'user') {
       result.push({
         role: 'user',
         content: msg.content,
-        timestamp: Date.now(),
+        timestamp,
       } satisfies UserMessage as AgentMessage);
       continue;
     }
@@ -49,7 +51,7 @@ export function toAgentMessages(messages: FrontendMessage[]): AgentMessage[] {
           model: '',
           usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
           stopReason: 'stop',
-          timestamp: Date.now(),
+          timestamp,
         } satisfies AssistantMessage as AgentMessage);
       }
       continue;
@@ -85,7 +87,7 @@ export function toAgentMessages(messages: FrontendMessage[]): AgentMessage[] {
         model: '',
         usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
         stopReason: toolCalls.length > 0 ? 'toolUse' : 'stop',
-        timestamp: Date.now(),
+        timestamp,
       } satisfies AssistantMessage as AgentMessage);
     }
 
@@ -97,7 +99,7 @@ export function toAgentMessages(messages: FrontendMessage[]): AgentMessage[] {
         toolName: tc.toolName,
         content: [{ type: 'text', text: tc.output ?? '' }],
         isError: tc.state === 'error',
-        timestamp: Date.now(),
+        timestamp,
       } satisfies ToolResultMessage as AgentMessage);
     }
   }

package/app/lib/core/agent-audit-log.ts

@@ -0,0 +1,280 @@
+import fs from 'fs';
+import path from 'path';
+
+export interface AgentAuditEvent {
+  id: string;
+  ts: string;
+  tool: string;
+  params: Record<string, unknown>;
+  result: 'ok' | 'error';
+  message?: string;
+  durationMs?: number;
+  op?: 'append' | 'legacy_agent_audit_md_import' | 'legacy_agent_log_jsonl_import';
+}
+
+export interface AgentAuditInput {
+  ts: string;
+  tool: string;
+  params: Record<string, unknown>;
+  result: 'ok' | 'error';
+  message?: string;
+  durationMs?: number;
+}
+
+interface AgentAuditState {
+  version: 1;
+  events: AgentAuditEvent[];
+  legacy?: {
+    mdImportedCount?: number;
+    jsonlImportedCount?: number;
+    lastImportedAt?: string | null;
+  };
+}
+
+const LOG_DIR_NAME = '.mindos';
+const LOG_FILE_NAME = 'agent-audit-log.json';
+const LEGACY_MD_FILE = 'Agent-Audit.md';
+const LEGACY_JSONL_FILE = '.agent-log.json';
+const MAX_EVENTS = 1000;
+const MAX_MESSAGE_CHARS = 2000;
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function validIso(ts: string | undefined): string {
+  if (!ts) return nowIso();
+  const ms = new Date(ts).getTime();
+  return Number.isFinite(ms) ? new Date(ms).toISOString() : nowIso();
+}
+
+function normalizeMessage(message: string | undefined): string | undefined {
+  if (typeof message !== 'string') return undefined;
+  if (message.length <= MAX_MESSAGE_CHARS) return message;
+  return message.slice(0, MAX_MESSAGE_CHARS);
+}
+
+function defaultState(): AgentAuditState {
+  return {
+    version: 1,
+    events: [],
+    legacy: {
+      mdImportedCount: 0,
+      jsonlImportedCount: 0,
+      lastImportedAt: null,
+    },
+  };
+}
+
+function logPath(mindRoot: string) {
+  return path.join(mindRoot, LOG_DIR_NAME, LOG_FILE_NAME);
+}
+
+function readState(mindRoot: string): AgentAuditState {
+  const file = logPath(mindRoot);
+  try {
+    if (!fs.existsSync(file)) return defaultState();
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf-8')) as Partial<AgentAuditState>;
+    if (!Array.isArray(parsed.events)) return defaultState();
+    return {
+      version: 1,
+      events: parsed.events,
+      legacy: {
+        mdImportedCount: typeof parsed.legacy?.mdImportedCount === 'number' ? parsed.legacy.mdImportedCount : 0,
+        jsonlImportedCount: typeof parsed.legacy?.jsonlImportedCount === 'number' ? parsed.legacy.jsonlImportedCount : 0,
+        lastImportedAt: typeof parsed.legacy?.lastImportedAt === 'string' ? parsed.legacy.lastImportedAt : null,
+      },
+    };
+  } catch {
+    return defaultState();
+  }
+}
+
+function writeState(mindRoot: string, state: AgentAuditState): void {
+  const file = logPath(mindRoot);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(state, null, 2), 'utf-8');
+}
+
+function removeLegacyFile(filePath: string): void {
+  try {
+    fs.rmSync(filePath, { force: true });
+  } catch {
+    // Keep migration best-effort.
+  }
+}
+
+interface LegacyAgentOp {
+  ts?: string;
+  tool?: string;
+  params?: Record<string, unknown>;
+  result?: 'ok' | 'error';
+  message?: string;
+  durationMs?: number;
+}
+
+function parseLegacyMdBlocks(raw: string): LegacyAgentOp[] {
+  const blocks: LegacyAgentOp[] = [];
+  const re = /```agent-op\s*\n([\s\S]*?)```/g;
+  let match: RegExpExecArray | null;
+  while ((match = re.exec(raw)) !== null) {
+    try {
+      blocks.push(JSON.parse(match[1].trim()) as LegacyAgentOp);
+    } catch {
+      // Ignore malformed blocks.
+    }
+  }
+  return blocks;
+}
+
+function parseJsonLines(raw: string): LegacyAgentOp[] {
+  const entries: LegacyAgentOp[] = [];
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('//')) continue;
+    try {
+      entries.push(JSON.parse(trimmed) as LegacyAgentOp);
+    } catch {
+      // Ignore malformed lines.
+    }
+  }
+  return entries;
+}
+
+function toEvent(entry: LegacyAgentOp, op: AgentAuditEvent['op'], idx: number): AgentAuditEvent {
+  const tool = typeof entry.tool === 'string' && entry.tool.trim() ? entry.tool.trim() : 'unknown-tool';
+  const result = entry.result === 'error' ? 'error' : 'ok';
+  const params = entry.params && typeof entry.params === 'object' ? entry.params : {};
+  return {
+    id: `legacy-${Date.now().toString(36)}-${idx.toString(36)}`,
+    ts: validIso(entry.ts),
+    tool,
+    params,
+    result,
+    message: normalizeMessage(entry.message),
+    durationMs: typeof entry.durationMs === 'number' ? entry.durationMs : undefined,
+    op,
+  };
+}
+
+function importLegacyMdIfNeeded(mindRoot: string, state: AgentAuditState): AgentAuditState {
+  const legacyPath = path.join(mindRoot, LEGACY_MD_FILE);
+  if (!fs.existsSync(legacyPath)) return state;
+
+  let raw = '';
+  try {
+    raw = fs.readFileSync(legacyPath, 'utf-8');
+  } catch {
+    return state;
+  }
+
+  const blocks = parseLegacyMdBlocks(raw);
+  const importedCount = state.legacy?.mdImportedCount ?? 0;
+  if (blocks.length <= importedCount) {
+    if (blocks.length > 0) removeLegacyFile(legacyPath);
+    return state;
+  }
+
+  const incoming = blocks.slice(importedCount);
+  const imported = incoming.map((entry, idx) => toEvent(entry, 'legacy_agent_audit_md_import', idx));
+  const merged = [...state.events, ...imported]
+    .sort((a, b) => new Date(b.ts).getTime() - new Date(a.ts).getTime())
+    .slice(0, MAX_EVENTS);
+
+  const next = {
+    ...state,
+    events: merged,
+    legacy: {
+      mdImportedCount: blocks.length,
+      jsonlImportedCount: state.legacy?.jsonlImportedCount ?? 0,
+      lastImportedAt: nowIso(),
+    },
+  };
+  removeLegacyFile(legacyPath);
+  return next;
+}
+
+function importLegacyJsonlIfNeeded(mindRoot: string, state: AgentAuditState): AgentAuditState {
+  const legacyPath = path.join(mindRoot, LEGACY_JSONL_FILE);
+  if (!fs.existsSync(legacyPath)) return state;
+
+  let raw = '';
+  try {
+    raw = fs.readFileSync(legacyPath, 'utf-8');
+  } catch {
+    return state;
+  }
+
+  const lines = parseJsonLines(raw);
+  const importedCount = state.legacy?.jsonlImportedCount ?? 0;
+  if (lines.length <= importedCount) {
+    if (lines.length > 0) removeLegacyFile(legacyPath);
+    return state;
+  }
+
+  const incoming = lines.slice(importedCount);
+  const imported = incoming.map((entry, idx) => toEvent(entry, 'legacy_agent_log_jsonl_import', idx));
+  const merged = [...state.events, ...imported]
+    .sort((a, b) => new Date(b.ts).getTime() - new Date(a.ts).getTime())
+    .slice(0, MAX_EVENTS);
+
+  const next = {
+    ...state,
+    events: merged,
+    legacy: {
+      mdImportedCount: state.legacy?.mdImportedCount ?? 0,
+      jsonlImportedCount: lines.length,
+      lastImportedAt: nowIso(),
+    },
+  };
+  removeLegacyFile(legacyPath);
+  return next;
+}
+
+function loadState(mindRoot: string): AgentAuditState {
+  const base = readState(mindRoot);
+  const mdMigrated = importLegacyMdIfNeeded(mindRoot, base);
+  const migrated = importLegacyJsonlIfNeeded(mindRoot, mdMigrated);
+  const changed =
+    base.events.length !== migrated.events.length ||
+    (base.legacy?.mdImportedCount ?? 0) !== (migrated.legacy?.mdImportedCount ?? 0) ||
+    (base.legacy?.jsonlImportedCount ?? 0) !== (migrated.legacy?.jsonlImportedCount ?? 0);
+  if (changed) writeState(mindRoot, migrated);
+  return migrated;
+}
+
+export function appendAgentAuditEvent(mindRoot: string, input: AgentAuditInput): AgentAuditEvent {
+  const state = loadState(mindRoot);
+  const event: AgentAuditEvent = {
+    id: `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+    ts: validIso(input.ts),
+    tool: input.tool,
+    params: input.params && typeof input.params === 'object' ? input.params : {},
+    result: input.result === 'error' ? 'error' : 'ok',
+    message: normalizeMessage(input.message),
+    durationMs: typeof input.durationMs === 'number' ? input.durationMs : undefined,
+    op: 'append',
+  };
+  state.events.unshift(event);
+  if (state.events.length > MAX_EVENTS) state.events = state.events.slice(0, MAX_EVENTS);
+  writeState(mindRoot, state);
+  return event;
+}
+
+export function listAgentAuditEvents(mindRoot: string, limit = 100): AgentAuditEvent[] {
+  const state = loadState(mindRoot);
+  const safeLimit = Math.max(1, Math.min(limit, 1000));
+  return state.events.slice(0, safeLimit);
+}
+
+export function parseAgentAuditJsonLines(raw: string): AgentAuditInput[] {
+  return parseJsonLines(raw).map((entry) => ({
+    ts: validIso(entry.ts),
+    tool: typeof entry.tool === 'string' && entry.tool.trim() ? entry.tool.trim() : 'unknown-tool',
+    params: entry.params && typeof entry.params === 'object' ? entry.params : {},
+    result: entry.result === 'error' ? 'error' : 'ok',
+    message: normalizeMessage(entry.message),
+    durationMs: typeof entry.durationMs === 'number' ? entry.durationMs : undefined,
+  }));
+}
+

package/app/lib/core/content-changes.ts

@@ -32,11 +32,18 @@ interface ChangeLogState {
   version: 1;
   lastSeenAt: string | null;
   events: ContentChangeEvent[];
+  legacy?: {
+    agentDiffImportedCount?: number;
+    lastImportedAt?: string | null;
+  };
 }
 
 interface ListOptions {
   path?: string;
   limit?: number;
+  source?: ContentChangeSource;
+  op?: string;
+  q?: string;
 }
 
 export interface ContentChangeSummary {
@@ -64,6 +71,10 @@ function defaultState(): ChangeLogState {
     version: 1,
     lastSeenAt: null,
     events: [],
+    legacy: {
+      agentDiffImportedCount: 0,
+      lastImportedAt: null,
+    },
   };
 }
 
@@ -87,6 +98,16 @@ function readState(mindRoot: string): ChangeLogState {
       version: 1,
       lastSeenAt: typeof parsed.lastSeenAt === 'string' ? parsed.lastSeenAt : null,
       events: parsed.events,
+      legacy: {
+        agentDiffImportedCount:
+          typeof parsed.legacy?.agentDiffImportedCount === 'number'
+            ? parsed.legacy.agentDiffImportedCount
+            : 0,
+        lastImportedAt:
+          typeof parsed.legacy?.lastImportedAt === 'string'
+            ? parsed.legacy.lastImportedAt
+            : null,
+      },
     };
   } catch {
     return defaultState();
@@ -99,8 +120,115 @@ function writeState(mindRoot: string, state: ChangeLogState): void {
   fs.writeFileSync(file, JSON.stringify(state, null, 2), 'utf-8');
 }
 
-export function appendContentChange(mindRoot: string, input: ContentChangeInput): ContentChangeEvent {
+interface LegacyAgentDiffEntry {
+  ts?: string;
+  path?: string;
+  tool?: string;
+  before?: string;
+  after?: string;
+}
+
+function parseLegacyAgentDiffBlocks(content: string): LegacyAgentDiffEntry[] {
+  const blocks: LegacyAgentDiffEntry[] = [];
+  const re = /```agent-diff\s*\n([\s\S]*?)```/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(content)) !== null) {
+    try {
+      const parsed = JSON.parse(m[1].trim()) as LegacyAgentDiffEntry;
+      blocks.push(parsed);
+    } catch {
+      // Skip malformed block, keep import best-effort.
+    }
+  }
+  return blocks;
+}
+
+function toValidIso(ts: string | undefined): string {
+  if (!ts) return nowIso();
+  const ms = new Date(ts).getTime();
+  return Number.isFinite(ms) ? new Date(ms).toISOString() : nowIso();
+}
+
+function removeLegacyFile(filePath: string): void {
+  try {
+    fs.rmSync(filePath, { force: true });
+  } catch {
+    // keep best-effort; migration should not fail main flow.
+  }
+}
+
+function importLegacyAgentDiffIfNeeded(mindRoot: string, state: ChangeLogState): ChangeLogState {
+  const legacyPath = path.join(mindRoot, 'Agent-Diff.md');
+  if (!fs.existsSync(legacyPath)) return state;
+
+  let raw = '';
+  try {
+    raw = fs.readFileSync(legacyPath, 'utf-8');
+  } catch {
+    return state;
+  }
+
+  const blocks = parseLegacyAgentDiffBlocks(raw);
+  const importedCount = state.legacy?.agentDiffImportedCount ?? 0;
+  if (blocks.length <= importedCount) {
+    // Already migrated before: remove legacy file to avoid stale duplicate source.
+    if (blocks.length > 0) removeLegacyFile(legacyPath);
+    return state;
+  }
+
+  const incoming = blocks.slice(importedCount);
+  const importedEvents: ContentChangeEvent[] = incoming.map((entry, idx) => {
+    const before = normalizeText(entry.before);
+    const after = normalizeText(entry.after);
+    const toolName = typeof entry.tool === 'string' && entry.tool.trim()
+      ? entry.tool.trim()
+      : 'unknown-tool';
+    const targetPath = typeof entry.path === 'string' && entry.path.trim()
+      ? entry.path
+      : 'Agent-Diff.md';
+    return {
+      id: `legacy-${Date.now().toString(36)}-${idx.toString(36)}`,
+      ts: toValidIso(entry.ts),
+      op: 'legacy_agent_diff_import',
+      path: targetPath,
+      source: 'agent',
+      summary: `Imported legacy agent diff (${toolName})`,
+      before: before.value,
+      after: after.value,
+      truncated: before.truncated || after.truncated || undefined,
+    };
+  });
+
+  const merged = [...state.events, ...importedEvents].sort(
+    (a, b) => new Date(b.ts).getTime() - new Date(a.ts).getTime(),
+  );
+
+  const nextState = {
+    ...state,
+    events: merged.slice(0, MAX_EVENTS),
+    legacy: {
+      agentDiffImportedCount: blocks.length,
+      lastImportedAt: nowIso(),
+    },
+  };
+  removeLegacyFile(legacyPath);
+  return nextState;
+}
+
+function loadState(mindRoot: string): ChangeLogState {
   const state = readState(mindRoot);
+  const migrated = importLegacyAgentDiffIfNeeded(mindRoot, state);
+  const changed =
+    (state.legacy?.agentDiffImportedCount ?? 0) !== (migrated.legacy?.agentDiffImportedCount ?? 0) ||
+    state.events.length !== migrated.events.length;
+  if (changed) {
+    writeState(mindRoot, migrated);
+  }
+  return migrated;
+}
+
+export function appendContentChange(mindRoot: string, input: ContentChangeInput): ContentChangeEvent {
+  const state = loadState(mindRoot);
   const before = normalizeText(input.before);
   const after = normalizeText(input.after);
   const event: ContentChangeEvent = {
@@ -125,23 +253,35 @@ export function appendContentChange(mindRoot: string, input: ContentChangeInput)
 }
 
 export function listContentChanges(mindRoot: string, options: ListOptions = {}): ContentChangeEvent[] {
-  const state = readState(mindRoot);
+  const state = loadState(mindRoot);
   const limit = Math.max(1, Math.min(options.limit ?? 50, 200));
-  const pathFilter = options.path;
-  const events = pathFilter
-    ? state.events.filter((event) => event.path === pathFilter || event.beforePath === pathFilter || event.afterPath === pathFilter)
-    : state.events;
+  const pathFilter = options.path?.trim();
+  const sourceFilter = options.source;
+  const opFilter = options.op?.trim();
+  const q = options.q?.trim().toLowerCase();
+  const events = state.events.filter((event) => {
+    if (pathFilter && event.path !== pathFilter && event.beforePath !== pathFilter && event.afterPath !== pathFilter) {
+      return false;
+    }
+    if (sourceFilter && event.source !== sourceFilter) return false;
+    if (opFilter && event.op !== opFilter) return false;
+    if (q) {
+      const haystack = `${event.path} ${event.beforePath ?? ''} ${event.afterPath ?? ''} ${event.summary} ${event.op} ${event.source}`.toLowerCase();
+      if (!haystack.includes(q)) return false;
+    }
+    return true;
+  });
   return events.slice(0, limit);
 }
 
 export function markContentChangesSeen(mindRoot: string): void {
-  const state = readState(mindRoot);
+  const state = loadState(mindRoot);
   state.lastSeenAt = nowIso();
   writeState(mindRoot, state);
 }
 
 export function getContentChangeSummary(mindRoot: string): ContentChangeSummary {
-  const state = readState(mindRoot);
+  const state = loadState(mindRoot);
   const lastSeenAtMs = state.lastSeenAt ? new Date(state.lastSeenAt).getTime() : 0;
   const unreadCount = state.events.filter((event) => new Date(event.ts).getTime() > lastSeenAtMs).length;
   return {

package/app/lib/core/index.ts

@@ -78,3 +78,14 @@ export type {
   ContentChangeSummary,
   ContentChangeSource,
 } from './content-changes';
+
+// Agent audit log
+export {
+  appendAgentAuditEvent,
+  listAgentAuditEvents,
+  parseAgentAuditJsonLines,
+} from './agent-audit-log';
+export type {
+  AgentAuditEvent,
+  AgentAuditInput,
+} from './agent-audit-log';

package/app/lib/fs.ts

@@ -57,6 +57,14 @@ interface FileTreeCache {
 let _cache: FileTreeCache | null = null;
 const CACHE_TTL_MS = 5_000; // 5 seconds
 
+let _treeVersion = 0;
+
+/** Monotonically increasing counter — bumped on every file mutation so the
+ *  client can cheaply detect changes without rebuilding the full tree. */
+export function getTreeVersion(): number {
+  return _treeVersion;
+}
+
 function isCacheValid(): boolean {
   return _cache !== null && (Date.now() - _cache.timestamp) < CACHE_TTL_MS;
 }
@@ -65,6 +73,7 @@ function isCacheValid(): boolean {
 export function invalidateCache(): void {
   _cache = null;
   _searchIndex = null;
+  _treeVersion++;
   invalidateSearchIndex();
 }
 
@@ -199,7 +208,13 @@ export function appendContentChange(input: ContentChangeInput): ContentChangeEve
   return coreAppendContentChange(getMindRoot(), input);
 }
 
-export function listContentChanges(options: { path?: string; limit?: number } = {}): ContentChangeEvent[] {
+export function listContentChanges(options: {
+  path?: string;
+  limit?: number;
+  source?: 'user' | 'agent' | 'system';
+  op?: string;
+  q?: string;
+} = {}): ContentChangeEvent[] {
   return coreListContentChanges(getMindRoot(), options);
 }