@ghl-ai/aw 0.1.37-beta.8 → 0.1.37

package/render-rules.mjs

@@ -0,0 +1,483 @@
+// render-rules.mjs — Render .aw_rules into IDE-specific output files.
+
+import { existsSync, readFileSync, mkdirSync, writeFileSync, readdirSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import * as fmt from './fmt.mjs';
+import { RULES_SOURCE_DIR } from './constants.mjs';
+
+const GENERATED_HEADER = '<!-- Generated by aw — do not edit manually -->\n\n';
+const STACK_OVERLAY_FLAG = 'AW_ENABLE_STACK_OVERLAY_RULES';
+
+/** Rule scope → Cursor .mdc glob patterns */
+const SCOPE_GLOBS = {
+  'api-design': '**/*.controller.ts,**/dto/**/*.ts,**/*.client.ts',
+  backend: '**/*.service.ts,**/*.controller.ts,**/*.module.ts,**/*.worker.ts',
+  'backend/go-connect': '**/*.connect.go,**/*.pb.go,**/buf.gen.yaml,**/buf.yaml',
+  'backend/nestjs': '**/*.controller.ts,**/*.module.ts,**/dto/**/*.ts,**/*.guard.ts,**/*.pipe.ts,**/*.interceptor.ts',
+  frontend: '**/*.vue,**/*.composable.ts,**/components/**/*.ts',
+  'frontend/nuxt': '**/app.vue,**/pages/**/*.vue,**/layouts/**/*.vue,**/plugins/**/*.ts,**/middleware/**/*.ts,**/server/api/**/*.ts,**/nuxt.config.*',
+  'frontend/vue': '**/*.vue,**/*.composable.ts,**/composables/**/*.ts',
+  data: '**/*.schema.ts,**/*.migration.*,**/*.repository.ts',
+  infra: '**/helm/**,**/terraform/**,**/Dockerfile*,**/Jenkinsfile*',
+  mobile: '**/*.dart,**/lib/**,**/widget_test/**',
+  sdet: '**/e2e/**,**/playwright/**,**/*.spec.ts',
+  security: '**/*.ts',
+  universal: '',
+};
+
+/**
+ * Read a file and return its content, or null if it doesn't exist.
+ */
+function readOrNull(path) {
+  try {
+    return readFileSync(path, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read manifest.json from rules dir.
+ */
+function readManifest(rulesDir) {
+  for (const filename of ['rule-manifest.json', 'manifest.json']) {
+    const content = readOrNull(join(rulesDir, filename));
+    if (!content) continue;
+    try {
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+function stripQuotes(value) {
+  return value.replace(/^['"]|['"]$/g, '');
+}
+
+function parseInlineList(value) {
+  const inner = value.trim().replace(/^\[/, '').replace(/\]$/, '');
+  if (!inner.trim()) return [];
+  return inner.split(',').map((item) => stripQuotes(item.trim())).filter(Boolean);
+}
+
+function parseRuleFrontmatter(markdown) {
+  const match = markdown.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+
+  const result = {};
+  let currentKey = null;
+
+  for (const rawLine of match[1].split('\n')) {
+    const line = rawLine.trimEnd();
+    if (!line.trim()) continue;
+
+    const listItem = line.match(/^\s*-\s+(.+)$/);
+    if (listItem && currentKey) {
+      if (!Array.isArray(result[currentKey])) result[currentKey] = [];
+      result[currentKey].push(stripQuotes(listItem[1].trim()));
+      continue;
+    }
+
+    const kv = line.match(/^([A-Za-z][A-Za-z0-9_-]*):\s*(.*)$/);
+    if (!kv) continue;
+
+    const [, key, rawValue] = kv;
+    currentKey = key;
+    const value = rawValue.trim();
+
+    if (value === '') {
+      result[key] = [];
+      continue;
+    }
+
+    if (value.startsWith('[') && value.endsWith(']')) {
+      result[key] = parseInlineList(value);
+      continue;
+    }
+
+    if (value === 'true') {
+      result[key] = true;
+      continue;
+    }
+
+    if (value === 'false') {
+      result[key] = false;
+      continue;
+    }
+
+    result[key] = stripQuotes(value);
+  }
+
+  return result;
+}
+
+function globToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+  const withGlobstar = escaped.replace(/\*\*/g, '::GLOBSTAR::');
+  const withStar = withGlobstar.replace(/\*/g, '[^/]*');
+  const finalPattern = withStar.replace(/::GLOBSTAR::/g, '.*');
+  return new RegExp(`^${finalPattern}$`);
+}
+
+function pathMatchesAnyPattern(filePath, patterns = []) {
+  if (!patterns.length) return true;
+  return patterns.some((pattern) => globToRegExp(pattern).test(filePath));
+}
+
+function textMatchesAny(content, patterns = []) {
+  if (!patterns.length) return true;
+  return patterns.some((pattern) => content.includes(pattern));
+}
+
+function importsMatchAny(content, imports = []) {
+  if (!imports.length) return true;
+  return imports.some((entry) => {
+    const escaped = entry.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const importRe = new RegExp(`(?:from\\s+['"]${escaped}['"]|require\\(\\s*['"]${escaped}['"]\\s*\\)|import\\s+['"]${escaped}['"])`);
+    return importRe.test(content);
+  });
+}
+
+export function ruleAppliesToFile(ruleMarkdown, { filePath = '', fileContent = '' } = {}) {
+  const frontmatter = parseRuleFrontmatter(ruleMarkdown);
+
+  if (frontmatter.fileLevel === false) return false;
+  if (!pathMatchesAnyPattern(filePath, frontmatter.paths || [])) return false;
+  if (!importsMatchAny(fileContent, frontmatter.requiresImports || [])) return false;
+  if (!textMatchesAny(fileContent, frontmatter.requiresText || [])) return false;
+
+  return true;
+}
+
+function scopeToFilename(scope) {
+  return scope.replaceAll('/', '-');
+}
+
+function scopeToLabel(scope) {
+  return scope.replaceAll('/', ' ');
+}
+
+function pruneStaleGeneratedRules(outputDir, expectedFilenames) {
+  if (!existsSync(outputDir)) return;
+
+  for (const entry of readdirSync(outputDir, { withFileTypes: true })) {
+    if (!entry.isFile()) continue;
+    if (expectedFilenames.has(entry.name)) continue;
+
+    const fullPath = join(outputDir, entry.name);
+    const content = readOrNull(fullPath);
+    if (!content?.startsWith(GENERATED_HEADER)) continue;
+
+    try {
+      unlinkSync(fullPath);
+    } catch {
+      // Best effort cleanup; stale files should not break rendering.
+    }
+  }
+}
+
+function stackOverlaysEnabled(options = {}) {
+  if (typeof options.enableStackOverlays === 'boolean') {
+    return options.enableStackOverlays;
+  }
+  return process.env[STACK_OVERLAY_FLAG] === '1';
+}
+
+/**
+ * List all rule scopes under rulesDir/platform/, including nested stack overlays.
+ */
+function listRuleScopes(rulesDir, { includeNestedScopes = false } = {}) {
+  const platformDir = join(rulesDir, 'platform');
+  if (!existsSync(platformDir)) return [];
+
+  const scopes = [];
+
+  function visit(relPath = '') {
+    const dirPath = relPath ? join(platformDir, relPath) : platformDir;
+    const agentsPath = join(dirPath, 'AGENTS.md');
+    if (relPath && existsSync(agentsPath)) {
+      scopes.push({
+        scope: relPath.replaceAll('\\', '/'),
+        agentsPath,
+        referencesDir: join(dirPath, 'references'),
+      });
+    }
+
+    // Default rollout keeps nested stack overlays off until explicitly enabled.
+    if (relPath && !includeNestedScopes) return;
+
+    for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name === 'references') continue;
+      const childRelPath = relPath ? `${relPath}/${entry.name}` : entry.name;
+      visit(childRelPath);
+    }
+  }
+
+  visit();
+
+  return scopes.sort((left, right) => {
+    const depthDiff = left.scope.split('/').length - right.scope.split('/').length;
+    if (depthDiff !== 0) return depthDiff;
+    return left.scope.localeCompare(right.scope);
+  });
+}
+
+/**
+ * Render .cursor/rules/<scope>.mdc files from .aw_rules scope AGENTS.md files.
+ */
+function renderCursorRules(cwd, rulesDir, options = {}) {
+  const cursorRulesDir = join(cwd, '.cursor', 'rules');
+  mkdirSync(cursorRulesDir, { recursive: true });
+
+  const scopes = listRuleScopes(rulesDir, {
+    includeNestedScopes: stackOverlaysEnabled(options),
+  });
+  pruneStaleGeneratedRules(
+    cursorRulesDir,
+    new Set(scopes.map(({ scope }) => `${scopeToFilename(scope)}.mdc`)),
+  );
+  let count = 0;
+
+  for (const { scope, agentsPath, referencesDir } of scopes) {
+    const agentsMd = readOrNull(agentsPath);
+    if (!agentsMd) continue;
+
+    const globs = SCOPE_GLOBS[scope] || '';
+    const alwaysApply = scope === 'universal' || scope === 'security';
+
+    // Build .mdc frontmatter
+    const frontmatter = [
+      '---',
+      `description: GHL ${scopeToLabel(scope)} coding rules`,
+    ];
+    if (alwaysApply) {
+      frontmatter.push('alwaysApply: true');
+    } else if (globs) {
+      frontmatter.push(`globs: ${globs}`);
+    }
+    frontmatter.push('---');
+
+    // Only add references listing if the AGENTS.md doesn't already have one
+    let refSection = '';
+    const hasReferences = agentsMd.includes('## References');
+    if (!hasReferences && existsSync(referencesDir)) {
+      const refs = readdirSync(referencesDir).filter(f => f.endsWith('.md')).sort();
+      if (refs.length > 0) {
+        refSection = '\n## References\n\n' +
+          refs.map(f => `- [${f.replace('.md', '')}](.aw_registry/.aw_rules/platform/${scope}/references/${f})`).join('\n') +
+          '\n';
+      }
+    }
+
+    const content = GENERATED_HEADER + frontmatter.join('\n') + '\n\n' + agentsMd.trim() + '\n' + refSection;
+    writeFileSync(join(cursorRulesDir, `${scopeToFilename(scope)}.mdc`), content);
+    count++;
+  }
+
+  return count;
+}
+
+/** Rule scope → Claude Code paths: frontmatter (only supported field for .claude/rules/) */
+const SCOPE_PATHS = {
+  'api-design': ['src/**/*.controller.ts', 'src/**/dto/**/*.ts', 'src/**/*.client.ts'],
+  backend: ['src/**/*.service.ts', 'src/**/*.controller.ts', 'src/**/*.module.ts', 'src/**/*.worker.ts'],
+  'backend/go-connect': ['**/*.connect.go', '**/*.pb.go', '**/buf.gen.yaml', '**/buf.yaml'],
+  'backend/nestjs': ['src/**/*.controller.ts', 'src/**/*.module.ts', 'src/**/dto/**/*.ts', 'src/**/*.guard.ts', 'src/**/*.pipe.ts', 'src/**/*.interceptor.ts'],
+  frontend: ['src/**/*.vue', 'src/**/*.composable.ts', 'src/**/components/**/*.ts'],
+  'frontend/nuxt': ['app.vue', 'pages/**/*.vue', 'layouts/**/*.vue', 'plugins/**/*.ts', 'middleware/**/*.ts', 'server/api/**/*.ts', 'nuxt.config.*'],
+  'frontend/vue': ['src/**/*.vue', 'src/**/*.composable.ts', 'src/**/composables/**/*.ts'],
+  data: ['src/**/*.schema.ts', 'src/**/*.migration.*', 'src/**/*.repository.ts'],
+  infra: ['**/helm/**', '**/terraform/**', '**/Dockerfile*', '**/Jenkinsfile*'],
+  mobile: ['**/*.dart', '**/lib/**', '**/widget_test/**'],
+  sdet: ['**/e2e/**', '**/playwright/**', '**/*.spec.ts'],
+  security: null,   // no paths = always loaded
+  universal: null,   // no paths = always loaded
+};
+
+const SCOPE_HINTS = {
+  'api-design': '`*.controller.ts`, `dto/*.ts`, service clients',
+  backend: '`*.service.ts`, `*.controller.ts`, `*.module.ts`, `*.worker.ts`',
+  'backend/go-connect': 'Connect-RPC Go handlers, generated stubs, `buf.yaml`',
+  'backend/nestjs': 'NestJS controllers, modules, DTOs, guards, pipes',
+  data: '`*.schema.ts`, `*.repository.ts`, `migrations/*`',
+  frontend: '`*.vue`, `composables/*.ts`, `stores/*.ts`',
+  'frontend/nuxt': 'Nuxt `app.vue`, pages, layouts, plugins, `server/api`',
+  'frontend/vue': 'Vue SFCs and shared Vue composables',
+  infra: '`*.tf`, `*.yaml`, `Jenkinsfile`, `Dockerfile`, `helm/*`',
+  mobile: '`*.dart`, `lib/**`, widget tests',
+  sdet: 'Playwright tests, `*.spec.ts` in test repos',
+  security: 'Auth, secrets, input handling, rendering (always)',
+  universal: 'All files (always)',
+};
+
+/**
+ * Render .claude/rules/platform/<scope>.md files from .aw_rules scope AGENTS.md files.
+ * Claude Code supports `paths:` frontmatter — rules with paths load only for matching files.
+ * Rules without paths are loaded unconditionally.
+ */
+function renderClaudeRules(cwd, rulesDir, options = {}) {
+  const claudeRulesDir = join(cwd, '.claude', 'rules', 'platform');
+  mkdirSync(claudeRulesDir, { recursive: true });
+
+  const scopes = listRuleScopes(rulesDir, {
+    includeNestedScopes: stackOverlaysEnabled(options),
+  });
+  pruneStaleGeneratedRules(
+    claudeRulesDir,
+    new Set(scopes.map(({ scope }) => `${scopeToFilename(scope)}.md`)),
+  );
+  let count = 0;
+
+  for (const { scope, agentsPath, referencesDir } of scopes) {
+    const agentsMd = readOrNull(agentsPath);
+    if (!agentsMd) continue;
+
+    // Build paths frontmatter for scope-specific rules
+    const paths = SCOPE_PATHS[scope];
+    let frontmatter = '';
+    if (paths) {
+      frontmatter = '---\npaths:\n' + paths.map(p => `  - "${p}"`).join('\n') + '\n---\n\n';
+    }
+
+    let refSection = '';
+    if (!agentsMd.includes('## References') && existsSync(referencesDir)) {
+      const refs = readdirSync(referencesDir).filter(f => f.endsWith('.md')).sort();
+      if (refs.length > 0) {
+        refSection = '\n## References\n\n' +
+          refs.map(f => `- [${f.replace('.md', '')}](.aw_registry/.aw_rules/platform/${scope}/references/${f})`).join('\n') +
+          '\n';
+      }
+    }
+
+    const content = GENERATED_HEADER + frontmatter + agentsMd.trim() + '\n' + refSection;
+    writeFileSync(join(claudeRulesDir, `${scopeToFilename(scope)}.md`), content);
+    count++;
+  }
+
+  return count;
+}
+
+/**
+ * Generate a rules section for CLAUDE.md from .aw_rules.
+ */
+export function generateClaudeMdRulesSection(rulesDir) {
+  const manifest = readManifest(rulesDir);
+  if (!manifest) return '';
+
+  const mustRules = manifest.rules.filter(r => r.severity === 'MUST');
+  if (mustRules.length === 0) return '';
+
+  const lines = [
+    '## Platform Rules (MUST)',
+    '',
+    '> Auto-synced from `.aw_registry/.aw_rules/`. Full details in reference files.',
+    '',
+  ];
+
+  for (const rule of mustRules) {
+    lines.push(`- [ ] **${rule.id}** — ${rule.description}`);
+  }
+
+  lines.push('');
+  lines.push('See `.aw_registry/.aw_rules/rule-manifest.json` for all rules including SHOULD/MAY.');
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+/**
+ * Generate a rules section for AGENTS.md from the top-level AGENTS.md in .aw_rules.
+ */
+export function generateAgentsMdRulesSection(rulesDir, options = {}) {
+  const topLevelAgents = readOrNull(join(rulesDir, 'AGENTS.md'));
+  if (!topLevelAgents) return '';
+
+  const lines = [
+    '## Platform Rules — Non-Negotiables',
+    '',
+    '> Auto-synced from `.aw_registry/.aw_rules/`.',
+    '',
+    topLevelAgents.trim(),
+    '',
+  ];
+
+  // Reference table — tells all IDEs (especially Codex) where to read domain rules.
+  // Codex can't auto-trigger by glob, but it CAN read these files when working in
+  // the matching area. Keep AGENTS.md lean; full content stays in the source files.
+  const scopes = listRuleScopes(rulesDir, {
+    includeNestedScopes: stackOverlaysEnabled(options),
+  });
+  const domains = scopes.filter(({ scope }) => !scope.includes('/'));
+  const overlays = scopes.filter(({ scope }) => scope.includes('/'));
+  if (domains.length > 0) {
+    lines.push('### Domain Rules');
+    lines.push('');
+    lines.push('When working in a specific domain, read the matching rules file:');
+    lines.push('');
+    lines.push('| Domain | Read when editing | Rules file |');
+    lines.push('|--------|-------------------|------------|');
+
+    for (const { scope } of domains) {
+      const hint = SCOPE_HINTS[scope] || 'Related files';
+      lines.push(`| ${scope} | ${hint} | \`.aw_registry/.aw_rules/platform/${scope}/AGENTS.md\` |`);
+    }
+    lines.push('');
+  }
+
+  if (overlays.length > 0) {
+    lines.push('### Stack Overlays');
+    lines.push('');
+    lines.push('When a repo or file clearly matches a stack-specific slice, also read the matching overlay:');
+    lines.push('');
+    lines.push('| Scope | Read when editing | Rules file |');
+    lines.push('|-------|-------------------|------------|');
+
+    for (const { scope } of overlays) {
+      const hint = SCOPE_HINTS[scope] || 'Stack-specific files';
+      lines.push(`| ${scope} | ${hint} | \`.aw_registry/.aw_rules/platform/${scope}/AGENTS.md\` |`);
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Main render function. Call after aw pull / aw sync.
+ * Reads .aw_registry/.aw_rules/ and renders:
+ *   1. .cursor/rules/<scope>.mdc — at cwd AND at $HOME (global)
+ *   2. Returns sections for CLAUDE.md and AGENTS.md injection
+ */
+export function renderRules(cwd, options = {}) {
+  const rulesDir = join(cwd, '.aw_registry', RULES_SOURCE_DIR);
+  if (!existsSync(rulesDir)) return { cursorCount: 0, claudeSection: '', agentsSection: '' };
+
+  const cursorCount = renderCursorRules(cwd, rulesDir, options);
+  const claudeCount = renderClaudeRules(cwd, rulesDir, options);
+  const claudeSection = generateClaudeMdRulesSection(rulesDir);
+  const agentsSection = generateAgentsMdRulesSection(rulesDir, options);
+
+  // Also render to global dirs so rules apply everywhere
+  const HOME = options.homeDir || homedir();
+  let globalCursorCount = 0;
+  let globalClaudeCount = 0;
+  if (cwd !== HOME) {
+    globalCursorCount = renderCursorRules(HOME, rulesDir, options);
+    globalClaudeCount = renderClaudeRules(HOME, rulesDir, options);
+  }
+
+  const total = cursorCount + claudeCount + globalCursorCount + globalClaudeCount;
+  if (total > 0) {
+    const parts = [];
+    if (cursorCount > 0) parts.push(`${cursorCount} .cursor/rules`);
+    if (claudeCount > 0) parts.push(`${claudeCount} .claude/rules`);
+    if (globalCursorCount > 0 || globalClaudeCount > 0) parts.push(`global`);
+    fmt.logSuccess(`Rendered ${parts.join(' + ')}`);
+  }
+
+  // Codex gets top-level non-negotiables plus rule file references via AGENTS.md.
+  return { cursorCount, claudeCount, claudeSection, agentsSection };
+}

package/slack-sim/fake-slack.mjs

@@ -0,0 +1,200 @@
+export class FakeSlackClient {
+  constructor() {
+    this.botUserId = 'U_GHL_AW';
+    this.botBotId = 'B_GHL_AW';
+    this.seq = 1;
+    this.messages = [];
+    this.uploads = [];
+    this.unfurls = [];
+
+    this.auth = {
+      test: async () => ({ user_id: this.botUserId, bot_id: this.botBotId }),
+    };
+
+    this.chat = {
+      postMessage: async (payload) => this.postMessage(payload),
+      update: async (payload) => this.updateMessage(payload),
+      delete: async (payload) => this.deleteMessage(payload),
+      unfurl: async (payload) => {
+        this.unfurls.push(payload);
+        return { ok: true };
+      },
+    };
+
+    this.conversations = {
+      replies: async ({ channel, ts }) => ({ messages: this.getThreadMessages(channel, ts) }),
+    };
+
+    this.reactions = {
+      add: async ({ channel, name, timestamp }) => {
+        const msg = this.findMessage(channel, timestamp);
+        if (msg) msg.reactions.add(name);
+        return { ok: true };
+      },
+      remove: async ({ channel, name, timestamp }) => {
+        const msg = this.findMessage(channel, timestamp);
+        if (msg) msg.reactions.delete(name);
+        return { ok: true };
+      },
+    };
+
+    this.files = {
+      sharedPublicURL: async ({ file }) => ({ ok: true, file: { permalink_public: `https://slack-files.com/public-${file}` } }),
+      info: async ({ file }) => ({ ok: true, file: this.findFile(file) }),
+      uploadV2: async (payload) => this.uploadFile(payload),
+    };
+  }
+
+  nextTs() {
+    const ts = `${1000 + Math.floor(this.seq / 1000)}.${String(this.seq).padStart(3, '0')}`;
+    this.seq += 1;
+    return ts;
+  }
+
+  normalizeFile(file = {}) {
+    const name = file.name || file.title || `file-${this.seq}`;
+    const mimetype = file.mimetype || (file.filetype ? `image/${file.filetype}` : 'application/octet-stream');
+    const contentBase64 = file.contentBase64 || file.data;
+    return {
+      id: file.id || `F${this.seq}`,
+      name,
+      title: file.title,
+      mimetype,
+      filetype: file.filetype || name.split('.').pop() || 'bin',
+      permalink: file.permalink || `https://slack.local/files/${name}`,
+      permalink_public: file.permalink_public,
+      original_w: file.original_w,
+      original_h: file.original_h,
+      plain_text: file.plain_text,
+      preview: file.preview,
+      size: file.size || (contentBase64 ? Math.round((contentBase64.length * 3) / 4) : undefined),
+      url_private_download: file.url_private_download || (contentBase64 ? `data:${mimetype};base64,${contentBase64}` : undefined),
+      url_private: file.url_private || (contentBase64 ? `data:${mimetype};base64,${contentBase64}` : undefined),
+    };
+  }
+
+  addIncomingMessage({ channel, user, text, ts, thread_ts, files = [], blocks = [], attachments = [], subtype, bot_id }) {
+    const message = {
+      channel,
+      user,
+      text,
+      ts: ts || this.nextTs(),
+      thread_ts,
+      subtype,
+      bot_id,
+      blocks,
+      attachments,
+      files: files.map((f) => this.normalizeFile(f)),
+      reactions: new Set(),
+    };
+    this.messages.push(message);
+    return message;
+  }
+
+  postMessage(payload) {
+    const message = {
+      channel: payload.channel,
+      user: this.botUserId,
+      bot_id: this.botBotId,
+      text: payload.text || '',
+      ts: payload.ts || this.nextTs(),
+      thread_ts: payload.thread_ts,
+      blocks: payload.blocks || [],
+      attachments: [],
+      files: [],
+      reactions: new Set(),
+    };
+    this.messages.push(message);
+    return { ok: true, ts: message.ts };
+  }
+
+  updateMessage(payload) {
+    const msg = this.findMessage(payload.channel, payload.ts);
+    if (msg) {
+      msg.text = payload.text || msg.text;
+      msg.blocks = payload.blocks || msg.blocks;
+    }
+    return { ok: true, ts: payload.ts };
+  }
+
+  deleteMessage(payload) {
+    this.messages = this.messages.filter((m) => !(m.channel === payload.channel && m.ts === payload.ts));
+    return { ok: true };
+  }
+
+  uploadFile(payload) {
+    const upload = {
+      channel: payload.channel_id,
+      thread_ts: payload.thread_ts,
+      filename: payload.filename,
+      title: payload.title,
+      sizeBytes: payload.file?.length || 0,
+    };
+    this.uploads.push(upload);
+    this.messages.push({
+      channel: payload.channel_id,
+      user: this.botUserId,
+      bot_id: this.botBotId,
+      text: `:paperclip: uploaded ${payload.filename}`,
+      ts: this.nextTs(),
+      thread_ts: payload.thread_ts,
+      blocks: [],
+      attachments: [],
+      files: [],
+      reactions: new Set(),
+    });
+    return { ok: true };
+  }
+
+  findMessage(channel, ts) {
+    return this.messages.find((m) => m.channel === channel && m.ts === ts);
+  }
+
+  findFile(fileId) {
+    for (const message of this.messages) {
+      const file = message.files?.find((f) => f.id === fileId);
+      if (file) return file;
+    }
+    return null;
+  }
+
+  getThreadMessages(channel, rootTs) {
+    return this.messages
+      .filter((m) => m.channel === channel && (m.ts === rootTs || m.thread_ts === rootTs))
+      .sort((a, b) => Number(a.ts) - Number(b.ts))
+      .map((m) => ({
+        user: m.user,
+        bot_id: m.bot_id,
+        text: m.text,
+        ts: m.ts,
+        thread_ts: m.thread_ts,
+        blocks: m.blocks,
+        attachments: m.attachments,
+        files: m.files,
+        subtype: m.subtype,
+      }));
+  }
+
+  latestThreadMessages(channel, threadTs) {
+    return this.getThreadMessages(channel, threadTs).map((m) => ({
+      ts: m.ts,
+      user: m.user || m.bot_id,
+      text: m.text,
+    }));
+  }
+
+  findLastBotMessageWithAction(channel, threadTs, actionId) {
+    const messages = this.messages
+      .filter((m) => m.channel === channel && (m.ts === threadTs || m.thread_ts === threadTs))
+      .filter((m) => m.bot_id === this.botBotId)
+      .reverse();
+    for (const msg of messages) {
+      for (const block of msg.blocks || []) {
+        for (const el of block.elements || []) {
+          if (el.action_id === actionId) return { message: msg, action: el };
+        }
+      }
+    }
+    return null;
+  }
+}