amalgm 0.1.88 → 0.1.89

package/runtime/scripts/chat-core/tooling/active-memory.js

@@ -1,574 +0,0 @@
-'use strict';
-
-const crypto = require('crypto');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-const AMALGM_DIR = process.env.AMALGM_DIR || path.join(os.homedir(), '.amalgm');
-
-const ACTIVE_MEMORY_DIRNAME = '.memories';
-const ACTIVE_MEMORY_ROOT = path.join(AMALGM_DIR, ACTIVE_MEMORY_DIRNAME);
-const CONTEXT_DIRNAME = 'context';
-const PROJECT_CONTEXT_DIR = path.join('.amalgm', CONTEXT_DIRNAME);
-const INSTRUCTIONS_FILENAME = 'instructions.md';
-const MEMORIES_FILENAME = 'memories.md';
-const REFERENCES_DIRNAME = 'references';
-const MAX_CONTEXT_FILE_CHARS = 12_000;
-
-const BASE_FILES = [
-  { scopeType: 'global', title: 'Global Active Memory', relativePath: 'active.md' },
-  { scopeType: 'tasks', title: 'Task Active Memory', relativePath: 'tasks.md' },
-  { scopeType: 'events', title: 'Event Active Memory', relativePath: 'events.md' },
-  { scopeType: 'apps', title: 'App Active Memory', relativePath: 'apps.md' },
-  { scopeType: 'tools', title: 'Tool Active Memory', relativePath: 'tools.md' },
-  { scopeType: 'projects', title: 'Project Active Memory', relativePath: 'projects.md' },
-  { scopeType: 'folders', title: 'Folder Active Memory', relativePath: 'folders.md' },
-];
-
-const CONSTRUCT_FOLDERS = {
-  app: 'apps',
-  artifact: 'apps',
-  event: 'events',
-  folder: 'folders',
-  project: 'projects',
-  task: 'tasks',
-  tool: 'tools',
-  workspace: 'projects',
-};
-
-function hash(value) {
-  return crypto.createHash('sha256').update(String(value || '')).digest('hex').slice(0, 20);
-}
-
-function cleanString(value) {
-  return typeof value === 'string' && value.trim() ? value.trim() : '';
-}
-
-function safeSegment(value, fallback = 'memory') {
-  const cleaned = cleanString(value)
-    .replace(/[^A-Za-z0-9._-]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-    .slice(0, 80);
-  return cleaned || `${fallback}-${hash(value)}`;
-}
-
-function isWithin(root, target) {
-  const relative = path.relative(path.resolve(root), path.resolve(target));
-  return relative === '' || (!!relative && !relative.startsWith('..') && !path.isAbsolute(relative));
-}
-
-function activeMemoryRoot() {
-  return ACTIVE_MEMORY_ROOT;
-}
-
-function systemContextRoot() {
-  return path.join(AMALGM_DIR, CONTEXT_DIRNAME);
-}
-
-function projectContextRoot(projectPath) {
-  const resolved = cleanString(projectPath) ? path.resolve(projectPath) : '';
-  if (!resolved) return '';
-  return path.join(resolved, PROJECT_CONTEXT_DIR);
-}
-
-function ensureContext(root, name, options = {}) {
-  if (!root) return [];
-  const created = [];
-  fs.mkdirSync(root, { recursive: true });
-  fs.mkdirSync(path.join(root, REFERENCES_DIRNAME), { recursive: true });
-  const instructionsPath = path.join(root, INSTRUCTIONS_FILENAME);
-  const memoriesPath = path.join(root, MEMORIES_FILENAME);
-  if (ensurePlainFile(instructionsPath, instructionsTemplate(name || 'this context'))) {
-    created.push(instructionsPath);
-  }
-  if (ensureFile(memoriesPath, `${name || 'Context'} Memories`, {
-    scopeType: options.scopeType || 'project',
-    scopeId: options.scopeId,
-    name,
-    projectPath: options.projectPath,
-  })) {
-    created.push(memoriesPath);
-  }
-  return created;
-}
-
-function ensureSystemContext(options = {}) {
-  const created = ensureContext(systemContextRoot(), 'Amalgm System', {
-    scopeType: 'system',
-    scopeId: 'system',
-    projectPath: AMALGM_DIR,
-  });
-  if (created.length > 0 && options.publish) {
-    publishMemoriesChange(options.source || 'active-memory:system-context');
-  }
-  return created;
-}
-
-function ensureProjectContext(input = {}, options = {}) {
-  const projectPath = cleanString(input.projectPath || input.path);
-  const root = projectContextRoot(projectPath);
-  if (!root) return [];
-  const name = cleanString(input.name) || (projectPath ? path.basename(path.resolve(projectPath)) : '') || 'Project';
-  const created = ensureContext(root, name, {
-    scopeType: 'project',
-    scopeId: cleanString(input.id || input.scopeId),
-    projectPath: path.resolve(projectPath),
-  });
-  if (created.length > 0 && options.publish) {
-    publishMemoriesChange(options.source || 'active-memory:project-context');
-  }
-  return created;
-}
-
-function activeMemoryTemplate(title, details = {}) {
-  const lines = [
-    `# ${title}`,
-    '',
-    'Agents maintain this active memory file. Keep durable, currently useful facts here and remove stale notes.',
-  ];
-  if (details.scopeType) lines.push(`scope: ${details.scopeType}`);
-  if (details.scopeId) lines.push(`scope_id: ${details.scopeId}`);
-  if (details.name) lines.push(`name: ${details.name}`);
-  if (details.projectPath) lines.push(`project_path: ${details.projectPath}`);
-  lines.push('', '- No durable notes yet.', '');
-  return lines.join('\n');
-}
-
-function instructionsTemplate(title) {
-  return [
-    '# Instructions',
-    '',
-    `No instructions for ${title} yet.`,
-    '',
-  ].join('\n');
-}
-
-function ensureFile(filePath, title, details = {}) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  if (fs.existsSync(filePath)) return false;
-  fs.writeFileSync(filePath, activeMemoryTemplate(title, details), 'utf8');
-  return true;
-}
-
-function ensurePlainFile(filePath, content) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  if (fs.existsSync(filePath)) return false;
-  fs.writeFileSync(filePath, content, 'utf8');
-  return true;
-}
-
-function statFile(filePath) {
-  try {
-    return fs.statSync(filePath);
-  } catch {
-    return null;
-  }
-}
-
-function readFile(filePath, maxChars = MAX_CONTEXT_FILE_CHARS) {
-  try {
-    const text = fs.readFileSync(filePath, 'utf8');
-    if (text.length <= maxChars) return text;
-    return `${text.slice(0, maxChars).trim()}\n[truncated]`;
-  } catch {
-    return '';
-  }
-}
-
-function basename(filePath) {
-  return path.basename(filePath);
-}
-
-function titleFromPath(filePath) {
-  return basename(filePath).replace(/\.md$/i, '').replace(/[-_]+/g, ' ') || 'Active Memory';
-}
-
-function fileRecord(filePath, extra = {}, options = {}) {
-  const stat = statFile(filePath);
-  if (!stat || !stat.isFile()) return null;
-  const record = {
-    id: `memory_${hash(path.resolve(filePath))}`,
-    path: path.resolve(filePath),
-    name: basename(filePath),
-    title: extra.title || titleFromPath(filePath),
-    kind: 'active',
-    scopeType: extra.scopeType || null,
-    scopeId: extra.scopeId || null,
-    modTime: stat.mtime.toISOString(),
-    size: stat.size,
-    writable: true,
-    generated: true,
-  };
-  if (options.includeContent) record.content = readFile(filePath, options.maxChars);
-  return record;
-}
-
-function publishMemoriesChange(source = 'active-memory') {
-  try {
-    const { appendStateEvent } = require('../../amalgm-mcp/state/events');
-    appendStateEvent({
-      resource: 'memories',
-      op: 'replace',
-      value: collectActiveMemoryFiles({ publish: false }),
-      source,
-    });
-  } catch (error) {
-    const message = error instanceof Error ? error.message.split('\n')[0] : String(error);
-    console.warn('[active-memory] Local Live Store publish failed:', message);
-  }
-}
-
-function ensureActiveMemoryLibrary(options = {}) {
-  const created = [];
-  fs.mkdirSync(ACTIVE_MEMORY_ROOT, { recursive: true });
-  for (const item of BASE_FILES) {
-    const filePath = path.join(ACTIVE_MEMORY_ROOT, item.relativePath);
-    if (ensureFile(filePath, item.title, { scopeType: item.scopeType })) {
-      created.push(filePath);
-    }
-  }
-  for (const dir of ['tasks', 'events', 'apps', 'tools', 'projects', 'folders']) {
-    fs.mkdirSync(path.join(ACTIVE_MEMORY_ROOT, dir), { recursive: true });
-  }
-  if (created.length > 0 && options.publish) {
-    publishMemoriesChange(options.source || 'active-memory:init');
-  }
-  return created;
-}
-
-function collectMarkdownFiles(root, out = []) {
-  let entries = [];
-  try {
-    entries = fs.readdirSync(root, { withFileTypes: true });
-  } catch {
-    return out;
-  }
-  for (const entry of entries) {
-    const fullPath = path.join(root, entry.name);
-    if (entry.isDirectory()) {
-      collectMarkdownFiles(fullPath, out);
-    } else if (entry.isFile() && /\.md$/i.test(entry.name)) {
-      out.push(fullPath);
-    }
-  }
-  return out;
-}
-
-function collectActiveMemoryFiles(options = {}) {
-  ensureActiveMemoryLibrary({ publish: false });
-  ensureSystemContext({ publish: false });
-  const contextMemoryFiles = [path.join(systemContextRoot(), MEMORIES_FILENAME)];
-  try {
-    const workspaceStore = require('../../amalgm-mcp/workspace/store');
-    for (const workspace of workspaceStore.listWorkspaces()) {
-      if (!workspace?.path) continue;
-      ensureProjectContext(workspace, { publish: false });
-      contextMemoryFiles.push(path.join(projectContextRoot(workspace.path), MEMORIES_FILENAME));
-    }
-  } catch {}
-
-  const files = [
-    ...collectMarkdownFiles(ACTIVE_MEMORY_ROOT),
-    ...contextMemoryFiles,
-  ]
-    .map((filePath) => fileRecord(filePath, {}, options))
-    .filter(Boolean);
-  files.sort((left, right) => {
-    const leftTime = left.modTime ? new Date(left.modTime).getTime() : 0;
-    const rightTime = right.modTime ? new Date(right.modTime).getTime() : 0;
-    if (leftTime !== rightTime) return rightTime - leftTime;
-    return left.path.localeCompare(right.path);
-  });
-  return files;
-}
-
-function isActiveMemoryPath(filePath) {
-  if (!cleanString(filePath)) return false;
-  if (isWithin(ACTIVE_MEMORY_ROOT, filePath)) return true;
-  const resolved = path.resolve(filePath);
-  return path.basename(resolved) === MEMORIES_FILENAME
-    && path.basename(path.dirname(resolved)) === CONTEXT_DIRNAME
-    && path.basename(path.dirname(path.dirname(resolved))) === '.amalgm';
-}
-
-function notifyMemoryPathChanged(filePath, source = 'fs') {
-  if (isActiveMemoryPath(filePath)) publishMemoriesChange(source);
-}
-
-function workspaceForProjectPath(projectPath) {
-  const resolved = cleanString(projectPath) ? path.resolve(projectPath) : '';
-  if (!resolved) return null;
-  try {
-    const workspaceStore = require('../../amalgm-mcp/workspace/store');
-    const workspaces = workspaceStore.listWorkspaces();
-    return workspaces
-      .filter((workspace) => workspace?.path && isWithin(workspace.path, resolved))
-      .sort((left, right) => String(right.path).length - String(left.path).length)[0] || null;
-  } catch {
-    return null;
-  }
-}
-
-function projectScope(projectPath) {
-  return constructScope({ type: 'project', projectPath });
-}
-
-function originFromContract(contract) {
-  const raw = contract?.origin && typeof contract.origin === 'object' ? contract.origin : {};
-  const type = cleanString(raw.type || contract?.originType);
-  const id = cleanString(raw.id || raw.originId || contract?.originId || contract?.taskId || contract?.triggerId);
-  if (!type || !id) return null;
-  return {
-    type,
-    id,
-    name: cleanString(raw.name || raw.originName || contract?.originName),
-    projectPath: cleanString(raw.projectPath || contract?.projectPath || contract?.cwd),
-  };
-}
-
-function originScope(origin) {
-  if (!origin) return null;
-  if (origin.type !== 'task' && origin.type !== 'event') return null;
-  return constructScope(origin);
-}
-
-function constructScope(input = {}) {
-  const rawType = cleanString(input.type || input.scopeType).toLowerCase();
-  const folder = CONSTRUCT_FOLDERS[rawType];
-  if (!folder) return null;
-
-  if (rawType === 'project' || rawType === 'workspace') {
-    const resolved = cleanString(input.projectPath || input.path) ? path.resolve(input.projectPath || input.path) : '';
-    const workspace = resolved ? workspaceForProjectPath(resolved) : null;
-    const scopeId = cleanString(input.id || input.scopeId) || workspace?.id || (resolved ? `path-${hash(resolved)}` : '');
-    if (!scopeId) return null;
-    const name = cleanString(input.name) || workspace?.name || (resolved ? path.basename(resolved) : '') || 'Project';
-    const projectPath = workspace?.path || resolved || cleanString(input.projectPath || input.path);
-    const contextRoot = projectContextRoot(projectPath);
-    return {
-      scopeType: 'project',
-      scopeId,
-      title: `${name} Active Memory`,
-      relativePath: path.join(folder, `${safeSegment(scopeId, 'project')}.md`),
-      filePath: contextRoot ? path.join(contextRoot, MEMORIES_FILENAME) : '',
-      name,
-      projectPath,
-    };
-  }
-
-  if (rawType === 'folder') {
-    const folderPath = cleanString(input.path || input.projectPath);
-    const scopeId = cleanString(input.id || input.scopeId) || (folderPath ? `path-${hash(path.resolve(folderPath))}` : '');
-    if (!scopeId) return null;
-    const name = cleanString(input.name) || (folderPath ? path.basename(path.resolve(folderPath)) : '') || 'Folder';
-    return {
-      scopeType: 'folder',
-      scopeId,
-      title: `${name} Active Memory`,
-      relativePath: path.join(folder, `${safeSegment(scopeId, 'folder')}.md`),
-      name,
-      projectPath: folderPath ? path.resolve(folderPath) : '',
-    };
-  }
-
-  const scopeId = cleanString(input.id || input.scopeId);
-  if (!scopeId) return null;
-  const titleType = rawType.charAt(0).toUpperCase() + rawType.slice(1);
-  const name = cleanString(input.name) || titleType;
-  return {
-    scopeType: rawType,
-    scopeId,
-    title: `${name} Active Memory`,
-    relativePath: path.join(folder, `${safeSegment(scopeId, rawType)}.md`),
-    name,
-    projectPath: cleanString(input.projectPath || input.path),
-  };
-}
-
-function ensureScopedFile(scope, options = {}) {
-  if (scope.scopeType === 'project' && scope.projectPath) {
-    ensureProjectContext(scope, { publish: false });
-  }
-  const filePath = scope.filePath || path.join(ACTIVE_MEMORY_ROOT, scope.relativePath);
-  const created = ensureFile(filePath, scope.title, scope);
-  if (created && options.publish) {
-    publishMemoriesChange(options.source || 'active-memory:scope');
-  }
-  const record = fileRecord(filePath, scope, { includeContent: options.includeContent, maxChars: options.maxChars });
-  if (record && created) record.created = true;
-  return record;
-}
-
-function ensureConstructMemory(input, options = {}) {
-  const scope = constructScope(input);
-  if (!scope) return null;
-  return ensureScopedFile(scope, {
-    includeContent: options.includeContent,
-    maxChars: options.maxChars,
-    publish: options.publish !== false,
-    source: options.source || `active-memory:${scope.scopeType}`,
-  });
-}
-
-function scopesForContract(contract) {
-  const scopes = [
-    { scopeType: 'global', title: 'Global Active Memory', relativePath: 'active.md' },
-    {
-      scopeType: 'system',
-      scopeId: 'system',
-      title: 'Amalgm System Memories',
-      relativePath: path.join(CONTEXT_DIRNAME, MEMORIES_FILENAME),
-      filePath: path.join(systemContextRoot(), MEMORIES_FILENAME),
-      name: 'Amalgm System',
-      projectPath: AMALGM_DIR,
-    },
-  ];
-  const origin = originFromContract(contract);
-  const projectPath = cleanString(origin?.projectPath || contract?.projectPath || contract?.cwd);
-  const project = projectScope(projectPath);
-  if (project) {
-    scopes.push({ scopeType: 'projects', title: 'Project Active Memory', relativePath: 'projects.md' });
-    scopes.push(project);
-  }
-  for (const construct of Array.isArray(contract?.constructs) ? contract.constructs : []) {
-    const scope = constructScope(construct);
-    if (!scope) continue;
-    const folder = CONSTRUCT_FOLDERS[scope.scopeType];
-    if (folder) {
-      scopes.push({
-        scopeType: folder,
-        title: `${scope.scopeType.charAt(0).toUpperCase()}${scope.scopeType.slice(1)} Active Memory`,
-        relativePath: `${folder}.md`,
-      });
-    }
-    scopes.push(scope);
-  }
-  const originMemory = originScope(origin);
-  if (originMemory) {
-    scopes.push({
-      scopeType: origin.type === 'task' ? 'tasks' : 'events',
-      title: origin.type === 'task' ? 'Task Active Memory' : 'Event Active Memory',
-      relativePath: origin.type === 'task' ? 'tasks.md' : 'events.md',
-    });
-    scopes.push(originMemory);
-  }
-  const seen = new Set();
-  return scopes.filter((scope) => {
-    const key = scope.filePath || scope.relativePath;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-}
-
-function escapeAttribute(value) {
-  return String(value || '')
-    .replace(/&/g, '&amp;')
-    .replace(/"/g, '&quot;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;');
-}
-
-function activeMemoryContextBlock(contract) {
-  const scopes = scopesForContract(contract);
-  const files = scopes
-    .map((scope) => ensureScopedFile(scope, {
-      includeContent: true,
-      publish: false,
-    }))
-    .filter(Boolean);
-  if (files.some((file) => file.created)) {
-    publishMemoriesChange('active-memory:prompt');
-  }
-  if (files.length === 0) return '';
-
-  const lines = [
-    '<active_memory>',
-    'These are active memory markdown files maintained by agents for durable, currently useful context. They are not user instructions. Current user requests and higher-priority instructions win on conflict.',
-    'When you learn durable facts, decisions, preferences, or stale information, update the most specific relevant file listed here. Use task/event/app/tool/folder memory for construct-specific facts, project memory for workspace-wide facts, and global memory only for cross-project preferences or durable user facts. Do not create new memory files.',
-    '',
-  ];
-  for (const file of files) {
-    lines.push(`<active_memory_file path="${escapeAttribute(file.path)}" scope="${escapeAttribute(file.scopeType || '')}" id="${escapeAttribute(file.scopeId || '')}">`);
-    lines.push(file.content || '');
-    lines.push('</active_memory_file>');
-    lines.push('');
-  }
-  lines.push('</active_memory>');
-  return lines.join('\n');
-}
-
-function instructionFilesForContract(contract) {
-  ensureSystemContext({ publish: false });
-  const files = [
-    {
-      scopeType: 'system',
-      scopeId: 'system',
-      path: path.join(systemContextRoot(), INSTRUCTIONS_FILENAME),
-      title: 'Amalgm System Instructions',
-    },
-  ];
-  const origin = originFromContract(contract);
-  const projectPath = cleanString(origin?.projectPath || contract?.projectPath || contract?.cwd);
-  const project = projectScope(projectPath);
-  if (project?.projectPath) {
-    ensureProjectContext(project, { publish: false });
-    files.push({
-      scopeType: 'project',
-      scopeId: project.scopeId,
-      path: path.join(projectContextRoot(project.projectPath), INSTRUCTIONS_FILENAME),
-      title: `${project.name || 'Project'} Instructions`,
-    });
-  }
-  return files;
-}
-
-function isEmptyInstructions(content, title) {
-  const body = String(content || '')
-    .replace(/^#\s*Instructions\s*/i, '')
-    .trim();
-  if (!body) return true;
-  const expected = `No instructions for ${title} yet.`;
-  return body === expected;
-}
-
-function instructionsContextBlock(contract) {
-  const files = instructionFilesForContract(contract)
-    .map((item) => ({
-      ...item,
-      content: readFile(item.path),
-    }))
-    .filter((item) => item.content && !isEmptyInstructions(item.content, item.title.replace(/\s+Instructions$/, '')));
-
-  if (files.length === 0) return '';
-
-  const lines = [
-    '<project_instructions>',
-    'These are user-authored markdown instruction files. Treat them as durable user instructions for their scope. Current user requests and higher-priority system/developer instructions win on conflict.',
-    '',
-  ];
-  for (const file of files) {
-    lines.push(`<instructions_file path="${escapeAttribute(file.path)}" scope="${escapeAttribute(file.scopeType)}" id="${escapeAttribute(file.scopeId || '')}">`);
-    lines.push(file.content);
-    lines.push('</instructions_file>');
-    lines.push('');
-  }
-  lines.push('</project_instructions>');
-  return lines.join('\n');
-}
-
-module.exports = {
-  activeMemoryContextBlock,
-  activeMemoryRoot,
-  collectActiveMemoryFiles,
-  ensureActiveMemoryLibrary,
-  ensureConstructMemory,
-  ensureProjectContext,
-  ensureSystemContext,
-  instructionsContextBlock,
-  isActiveMemoryPath,
-  notifyMemoryPathChanged,
-  publishMemoriesChange,
-  scopesForContract,
-};