mixdog 0.9.62 → 0.9.64

package/scripts/code-graph-root-federation-test.mjs

@@ -1,273 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
-import { join, parse } from 'node:path';
-import { homedir, tmpdir } from 'node:os';
-import { findCachedGraphBinary } from '../src/runtime/agent/orchestrator/tools/graph-binary-fetcher.mjs';
-
-const home = await mkdtemp(join(tmpdir(), 'mixdog-federation-home-'));
-const data = join(home, 'data');
-const ambientGraphBin = findCachedGraphBinary(join(process.env.MIXDOG_HOME || join(homedir(), '.mixdog'), 'data'));
-process.env.MIXDOG_HOME = home;
-process.env.MIXDOG_DATA_DIR = data;
-delete process.env.MIXDOG_SESSION_CWD;
-if (!process.env.MIXDOG_GRAPH_BIN && ambientGraphBin) process.env.MIXDOG_GRAPH_BIN = ambientGraphBin;
-
-const {
-  _isFilesystemRootPath,
-  collectTrustedCodeGraphRoots,
-} = await import('../src/runtime/agent/orchestrator/tools/code-graph/trusted-roots.mjs');
-const {
-  _codeGraphInflightKey,
-  _runGraphFilesChunked,
-  _scopeCodeGraphManifest,
-} = await import('../src/runtime/agent/orchestrator/tools/code-graph/build.mjs');
-
-test.after(() => rm(home, { recursive: true, force: true }));
-
-test('filesystem-root semantics recognize Unix and Windows roots only', () => {
-  assert.equal(_isFilesystemRootPath('/'), true);
-  assert.equal(_isFilesystemRootPath('C:\\'), true);
-  assert.equal(_isFilesystemRootPath('d:/'), true);
-  assert.equal(_isFilesystemRootPath('C:'), false);
-  assert.equal(_isFilesystemRootPath('/tmp'), false);
-  assert.equal(_isFilesystemRootPath('C:\\repo'), false);
-});
-
-test('trusted sources are unioned, normalized, deduped, and filtered', async () => {
-  const project = await mkdtemp(join(tmpdir(), 'mixdog-trusted-project-'));
-  const nested = join(project, 'nested');
-  await mkdir(nested);
-  await writeFile(join(nested, 'package.json'), '{}');
-  const missing = join(project, 'missing');
-  try {
-    const roots = collectTrustedCodeGraphRoots(parse(project).root, {
-      registered: () => [project, `${project}/`],
-      selected: () => [nested, parse(project).root],
-      cached: () => [project, missing],
-    });
-    assert.deepEqual(new Set(roots), new Set([project, nested]));
-  } finally {
-    await rm(project, { recursive: true, force: true });
-  }
-});
-
-test('nested project exclusion precedes cap selection and scoped truncation metadata', () => {
-  const parent = join(parse(process.cwd()).root, 'parent-scope');
-  const child = join(parent, 'child');
-  const manifest = [
-    { rel: 'child/a.mjs', fp: 'a' },
-    { rel: 'child/b.mjs', fp: 'b' },
-    { rel: 'child/c.mjs', fp: 'c' },
-    { rel: 'parent-one.mjs', fp: '1' },
-    { rel: 'parent-two.mjs', fp: '2' },
-  ];
-  const scoped = _scopeCodeGraphManifest(manifest, parent, {
-    excludedProjectRoots: [child],
-    maxFiles: 2,
-  });
-  assert.deepEqual(scoped.indexed.map((row) => row.rel), ['parent-one.mjs', 'parent-two.mjs']);
-  assert.equal(scoped.manifest.length, 2);
-  assert.equal(scoped.truncated, false);
-
-  const truncated = _scopeCodeGraphManifest(
-    [...manifest, { rel: 'parent-three.mjs', fp: '3' }],
-    parent,
-    { excludedProjectRoots: [child], maxFiles: 2 },
-  );
-  assert.equal(truncated.manifest.length, 3);
-  assert.equal(truncated.indexed.length, 2);
-  assert.equal(truncated.truncated, true);
-});
-
-test('nested Windows project exclusion is case-insensitive and containment-aware', () => {
-  const scoped = _scopeCodeGraphManifest([
-    { rel: 'Child/inside.mjs', fp: 'inside' },
-    { rel: 'childish/outside.mjs', fp: 'outside' },
-    { rel: 'parent.mjs', fp: 'parent' },
-  ], 'C:\\Repo', {
-    excludedProjectRoots: ['c:\\repo\\CHILD'],
-  });
-  assert.deepEqual(scoped.manifest.map((row) => row.rel), [
-    'childish/outside.mjs',
-    'parent.mjs',
-  ]);
-  assert.deepEqual(scoped.prefixes, ['child']);
-});
-
-test('scoped in-flight keys cannot collide through delimiters', () => {
-  const onePrefix = _codeGraphInflightKey('/repo', {
-    scoped: true,
-    maxFiles: 100,
-    prefixes: ['child|vendor'],
-  });
-  const twoPrefixes = _codeGraphInflightKey('/repo', {
-    scoped: true,
-    maxFiles: 100,
-    prefixes: ['child', 'vendor'],
-  });
-  assert.notEqual(onePrefix, twoPrefixes);
-  assert.notEqual(onePrefix, _codeGraphInflightKey('/repo'));
-});
-
-test('scoped --files builds use bounded chunks and merge relationship records', async () => {
-  const rels = Array.from({ length: 10_000 }, (_, index) => `src/file-${index}.mjs`);
-  const calls = [];
-  const records = await _runGraphFilesChunked('/repo', rels, [{ rel: 'reused.mjs' }], {
-    maxArgChars: 1_024,
-    runGraphFiles: async (_root, rels) => {
-      calls.push(rels);
-      return [
-        ...rels.map((rel) => ({ rel, fp: rel, resolvedImports: ['reused.mjs'] })),
-        { rel: 'reused.mjs', importedBy: [rels[0]] },
-      ];
-    },
-  });
-  assert.ok(calls.length > 1);
-  for (const rels of calls) {
-    assert.ok(rels.reduce((sum, rel) => sum + rel.length + 3, 0) <= 1_024);
-  }
-  assert.equal(records.filter((row) => row.rel !== 'reused.mjs').length, 10_000);
-  assert.deepEqual(new Set(records.map((row) => row.rel)), new Set([...rels, 'reused.mjs']));
-  assert.deepEqual(
-    new Set(records.find((row) => row.rel === 'reused.mjs').importedBy),
-    new Set(calls.map((rels) => rels[0])),
-  );
-});
-
-test('default trusted sources include actual registration, selected nested project, and cache manifest', async () => {
-  const parent = await mkdtemp(join(tmpdir(), 'mixdog-source-parent-'));
-  const child = join(parent, 'child');
-  const cached = await mkdtemp(join(tmpdir(), 'mixdog-source-cache-'));
-  await mkdir(child);
-  await writeFile(join(parent, 'package.json'), '{}');
-  await writeFile(join(child, 'package.json'), '{}');
-  await mkdir(join(data, 'code-graph-cache'), { recursive: true });
-  await writeFile(join(home, 'projects.json'), JSON.stringify({
-    projects: [{ name: 'parent', path: parent, addedAt: 1 }],
-  }));
-  await writeFile(join(data, 'code-graph-cache', 'manifest.json'), JSON.stringify({
-    [cached]: { hash: '12345678', builtAt: 1 },
-  }));
-  process.env.MIXDOG_SESSION_CWD = child;
-  try {
-    const roots = collectTrustedCodeGraphRoots(parse(parent).root);
-    assert.deepEqual(new Set(roots), new Set([parent, child, cached]));
-  } finally {
-    delete process.env.MIXDOG_SESSION_CWD;
-    await Promise.all([
-      rm(parent, { recursive: true, force: true }),
-      rm(cached, { recursive: true, force: true }),
-    ]);
-  }
-});
-
-test('root federation labels repositories, includes registered non-Git projects, and isolates failures', async () => {
-  const good = await mkdtemp(join(tmpdir(), 'mixdog-federated-good-'));
-  const bad = await mkdtemp(join(tmpdir(), 'mixdog-federated-bad-'));
-  await mkdir(join(good, 'src'));
-  await writeFile(join(good, 'package.json'), '{}');
-  await writeFile(join(good, 'src', 'good.mjs'), 'export function federatedNeedle() { return 1; }\n');
-  await writeFile(join(home, 'projects.json'), JSON.stringify({
-    projects: [
-      { name: 'good', path: good, addedAt: 2 },
-      { name: 'bad', path: bad, addedAt: 1 },
-    ],
-  }));
-  await writeFile(join(bad, 'package.json'), '{}');
-  const { executeCodeGraphTool } = await import('../src/runtime/agent/orchestrator/tools/code-graph/dispatch.mjs');
-  const result = await executeCodeGraphTool(
-    'code_graph',
-    { mode: 'symbol_search', symbol: 'federatedNeedle' },
-    parse(good).root,
-  );
-  assert.match(result, new RegExp(`# project .+ \\[${good.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\]`));
-  assert.match(result, /federatedNeedle/);
-  assert.match(result, new RegExp(`# project .+ \\[${bad.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\]`));
-  assert.match(result, /contains zero eligible files/);
-
-  await Promise.all([
-    rm(good, { recursive: true, force: true }),
-    rm(bad, { recursive: true, force: true }),
-  ]);
-});
-
-test('trusted file and relationship anchors route to owners; missing and untrusted anchors stop at root', async () => {
-  const project = await mkdtemp(join(tmpdir(), 'mixdog-file-route-'));
-  const untrusted = await mkdtemp(join(tmpdir(), 'mixdog-untrusted-route-'));
-  await writeFile(join(project, 'package.json'), '{}');
-  await writeFile(join(project, 'one.mjs'), 'export function routedNeedle() { return 1; }\n');
-  await writeFile(join(project, 'two.mjs'), "import { routedNeedle } from './one.mjs';\nexport const routedUse = routedNeedle();\n");
-  await writeFile(join(untrusted, 'package.json'), '{}');
-  await writeFile(join(untrusted, 'hidden.mjs'), 'export const hidden = 1;\n');
-  await writeFile(join(home, 'projects.json'), JSON.stringify({
-    projects: [{ name: 'route', path: project, addedAt: 1 }],
-  }));
-  const { executeCodeGraphTool } = await import('../src/runtime/agent/orchestrator/tools/code-graph/dispatch.mjs');
-  const root = parse(project).root;
-  const overview = await executeCodeGraphTool('code_graph', { mode: 'overview' }, root);
-  assert.match(overview, /# project .+\[/);
-  assert.match(overview, /files\t2/);
-  const imports = await executeCodeGraphTool('code_graph', { mode: 'imports', file: join(project, 'two.mjs') }, root);
-  assert.match(imports, /# project .+\[/);
-  assert.match(imports, /one\.mjs/);
-  const dependents = await executeCodeGraphTool('code_graph', {
-    mode: 'dependents',
-    file: join(project, 'one.mjs'),
-  }, root);
-  assert.match(dependents, /# project .+\[/);
-  assert.match(dependents, /two\.mjs/);
-  const missing = await executeCodeGraphTool('code_graph', {
-    mode: 'overview',
-    file: join(project, 'definitely-missing.mjs'),
-  }, root);
-  assert.match(missing, /^Error: code_graph: file not found:/);
-  assert.doesNotMatch(missing, /Same filename exists/);
-  const rejected = await executeCodeGraphTool('code_graph', {
-    mode: 'overview',
-    file: join(untrusted, 'hidden.mjs'),
-  }, root);
-  assert.match(rejected, /^Error: code_graph: file anchor is not owned by a trusted project:/);
-  await Promise.all([
-    rm(project, { recursive: true, force: true }),
-    rm(untrusted, { recursive: true, force: true }),
-  ]);
-});
-
-test('overlapping trusted roots keep nested symbols and edges out of the parent graph', async () => {
-  const parent = await mkdtemp(join(tmpdir(), 'mixdog-overlap-parent-'));
-  const child = join(parent, 'child');
-  await mkdir(child);
-  await writeFile(join(parent, 'package.json'), '{}');
-  await writeFile(join(parent, 'parent.mjs'), "import { childNeedle } from './child/child.mjs';\nexport const parentUse = childNeedle();\n");
-  await writeFile(join(child, 'package.json'), '{}');
-  await writeFile(join(child, 'child.mjs'), 'export function childNeedle() { return 1; }\n');
-  await writeFile(join(home, 'projects.json'), JSON.stringify({
-    projects: [
-      { name: 'parent', path: parent, addedAt: 2 },
-      { name: 'child', path: child, addedAt: 1 },
-    ],
-  }));
-  const { executeCodeGraphTool } = await import('../src/runtime/agent/orchestrator/tools/code-graph/dispatch.mjs');
-  const result = await executeCodeGraphTool('code_graph', {
-    mode: 'symbol_search',
-    symbol: 'childNeedle',
-  }, parse(parent).root);
-  const parentLabel = `# project ${parent.split(/[\\/]/).pop().toLowerCase()} [${parent.toLowerCase()}]`;
-  const childLabel = `# project ${child.split(/[\\/]/).pop().toLowerCase()} [${child.toLowerCase()}]`;
-  const normalized = result.toLowerCase();
-  const parentSection = normalized.slice(
-    normalized.indexOf(parentLabel),
-    normalized.indexOf(childLabel) > normalized.indexOf(parentLabel)
-      ? normalized.indexOf(childLabel)
-      : normalized.length,
-  );
-  assert.doesNotMatch(parentSection, /child\/child\.mjs|childneedle\s+\(/);
-  assert.match(normalized.slice(normalized.indexOf(childLabel)), /childneedle/);
-  const imports = await executeCodeGraphTool('code_graph', {
-    mode: 'imports',
-    file: join(parent, 'parent.mjs'),
-  }, parse(parent).root);
-  assert.doesNotMatch(imports.split('# raw')[0], /child\/child\.mjs/);
-  await rm(parent, { recursive: true, force: true });
-});

package/scripts/compact-active-turn-test.mjs

@@ -1,68 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import {
-    compactSessionMessages,
-    isSessionCompactionBlocked,
-    markSessionAskStart,
-    markSessionToolCall,
-    getSessionRuntime,
-} from '../src/runtime/agent/orchestrator/session/manager.mjs';
-import { loadSession, saveSessionAsync } from '../src/runtime/agent/orchestrator/session/store.mjs';
-
-test('isSessionCompactionBlocked is true while runtime reports tool_running with live controller', () => {
-    const sessionId = `sess_test_${process.pid}_${Date.now()}`;
-    const session = {
-        id: sessionId,
-        provider: 'openai',
-        model: 'gpt-4.1-mini',
-        messages: [
-            { role: 'user', content: 'one' },
-            { role: 'assistant', content: 'two' },
-            { role: 'user', content: 'three' },
-        ],
-        tools: [],
-        generation: 1,
-        closed: false,
-        compaction: { type: 1, compactType: 1 },
-        contextWindow: 128_000,
-    };
-    void saveSessionAsync(session, { expectedGeneration: 1 });
-    markSessionAskStart(sessionId);
-    markSessionToolCall(sessionId, 'read');
-    const entry = getSessionRuntime(sessionId);
-    entry.controller = new AbortController();
-
-    assert.equal(isSessionCompactionBlocked(sessionId), true);
-});
-
-test('compactSessionMessages returns no-op while turn is active', async () => {
-    const sessionId = `sess_test_compact_${process.pid}_${Date.now()}`;
-    const session = {
-        id: sessionId,
-        provider: 'openai',
-        model: 'gpt-4.1-mini',
-        messages: [
-            { role: 'user', content: 'one' },
-            { role: 'assistant', content: 'two' },
-            { role: 'user', content: 'three' },
-        ],
-        tools: [],
-        generation: 1,
-        closed: false,
-        compaction: { type: 1, compactType: 1 },
-        contextWindow: 128_000,
-    };
-    await saveSessionAsync(session, { expectedGeneration: 1 });
-    markSessionAskStart(sessionId);
-    markSessionToolCall(sessionId, 'grep');
-    const entry = getSessionRuntime(sessionId);
-    entry.controller = new AbortController();
-
-    const before = loadSession(sessionId);
-    const result = await compactSessionMessages(sessionId);
-    const after = loadSession(sessionId);
-
-    assert.equal(result?.changed, false);
-    assert.equal(result?.reason, 'compact skipped: turn in progress');
-    assert.deepEqual(after.messages, before.messages);
-});

package/scripts/compact-file-reattach-test.mjs

@@ -1,88 +0,0 @@
-import assert from 'node:assert/strict';
-import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { recallFastTrackCompactMessages, semanticCompactMessages } from '../src/runtime/agent/orchestrator/session/compact.mjs';
-import {
-  buildPostCompactFileAttachment,
-  MAX_REATTACH_FILES,
-  REATTACH_MAX_TOTAL_TOKENS,
-} from '../src/runtime/agent/orchestrator/session/compact/file-reattach.mjs';
-import { estimateTokens, sanitizeToolPairs } from '../src/runtime/agent/orchestrator/session/context-utils.mjs';
-
-const dir = mkdtempSync(join(tmpdir(), 'reattach-'));
-const fileA = join(dir, 'a.mjs'); writeFileSync(fileA, 'export const A = 1;\n'.repeat(50));
-const fileB = join(dir, 'b.mjs'); writeFileSync(fileB, 'export const B = 2;\n'.repeat(50));
-const fileHuge = join(dir, 'huge.txt'); writeFileSync(fileHuge, 'h'.repeat(600 * 1024)); // > 512KB cap
-const budgetFiles = Array.from({ length: 5 }, (_, i) => {
-  const p = join(dir, `budget-${i}.mjs`);
-  writeFileSync(p, `export const budget${i} = "${'token payload '.repeat(4000)}";\n`);
-  return p;
-});
-
-const readCall = (id, p) => ({ role: 'assistant', content: '', toolCalls: [{ id, name: 'read', arguments: JSON.stringify({ path: p }) }] });
-const toolRes = (id) => ({ role: 'tool', toolCallId: id, content: 'old cached body '.repeat(100) });
-
-function transcript() {
-  const msgs = [{ role: 'system', content: 'rules' }];
-  msgs.push({ role: 'user', content: 'fix bug in a.mjs' });
-  msgs.push(readCall('c1', fileA), toolRes('c1'));
-  msgs.push(readCall('c2', fileHuge), toolRes('c2'));
-  msgs.push(readCall('c3', join(dir, 'missing.mjs')), toolRes('c3'));
-  for (let i = 0; i < 12; i++) { msgs.push({ role: 'user', content: `iterate ${i} ` + 'pad '.repeat(300) }, { role: 'assistant', content: `ok ${i}` }); }
-  // newest turn reads fileB — must survive in tail and be skipped
-  msgs.push({ role: 'user', content: 'now check b.mjs' });
-  msgs.push(readCall('c9', fileB), toolRes('c9'));
-  msgs.push({ role: 'assistant', content: 'checked' });
-  return msgs;
-}
-
-// 1) fasttrack: A re-attached, B (in tail) skipped, huge+missing skipped
-{
-  const r = recallFastTrackCompactMessages(transcript(), 4000, { force: true, recallText: 'digest', allowEmptyRecall: true, tailTurns: 2, keepTokens: 2000, cwd: dir });
-  const ref = r.messages.find((m) => m.role === 'user' && typeof m.content === 'string' && m.content.startsWith('Reference files:'));
-  assert.ok(ref, 'fasttrack: reference-files message injected');
-  assert.ok(ref.content.includes(fileA), 'fileA re-attached');
-  assert.ok(ref.content.includes('export const A'), 'fileA fresh content present');
-  assert.ok(!ref.content.includes(fileHuge), 'huge file skipped');
-  assert.ok(!ref.content.includes('missing.mjs'), 'missing file skipped');
-  assert.ok(!ref.content.includes(fileB) || !ref.content.includes('export const B'), 'tail-surviving fileB not re-attached');
-  const refIdx = r.messages.indexOf(ref);
-  assert.equal(r.messages[refIdx + 1]?.role, 'assistant', 'ack follows reference message');
-  assert.equal(JSON.stringify(sanitizeToolPairs(r.messages)), JSON.stringify(r.messages), 'pairing valid');
-  assert.equal(r.diagnostics.fileReattached, true, 'diagnostics flag set');
-}
-// 2) semantic path with fake provider
-{
-  const provider = { name: 'fake', async send() { return { content: '## Goal\n- g\n\n## Constraints & Preferences\n- (none)\n\n## Progress\n### Done\n- d\n\n### In Progress\n- (none)\n\n### Blocked\n- (none)\n\n## Key Decisions\n- (none)\n\n## Next Steps\n- n\n\n## Critical Context\n- c\n\n## Relevant Files\n- a.mjs' }; } };
-  const r = await semanticCompactMessages(provider, transcript(), 'fake-model', 4000, { force: true, tailTurns: 1, cwd: dir });
-  const ref = r.messages.find((m) => m.role === 'user' && typeof m.content === 'string' && m.content.startsWith('Reference files:'));
-  assert.ok(ref, 'semantic: reference-files message injected');
-  assert.ok(ref.content.includes('export const A'), 'semantic: fileA fresh content');
-  assert.equal(r.diagnostics.fileReattached, true, 'semantic diagnostics flag');
-}
-// 3) no room -> no injection, still valid compact
-{
-  const r = recallFastTrackCompactMessages(transcript(), 1500, { force: true, recallText: 'digest', allowEmptyRecall: true, tailTurns: 1, keepTokens: 1200, cwd: dir });
-  assert.ok(Array.isArray(r.messages), 'tight budget compact still succeeds');
-  const ref = r.messages.find((m) => m.role === 'user' && typeof m.content === 'string' && m.content.startsWith('Reference files:'));
-  if (ref) assert.ok(r.diagnostics.finalTokens <= r.diagnostics.budgetTokens, 'reattach never exceeds budget');
-}
-// 4) env off-switch
-{
-  process.env.MIXDOG_COMPACT_FILE_REATTACH = '0';
-  const off = buildPostCompactFileAttachment([readCall('x', fileA)], [], 10000, { cwd: dir });
-  assert.equal(off, null, 'env kill-switch disables reattach');
-  delete process.env.MIXDOG_COMPACT_FILE_REATTACH;
-}
-// 5) generous context room is still bounded by the compact re-attach envelope
-{
-  const calls = budgetFiles.map((p, i) => readCall(`budget-${i}`, p));
-  const ref = buildPostCompactFileAttachment(calls, [], 50_000, { cwd: dir });
-  assert.ok(ref, 'bounded attachment should include at least one recent file');
-  assert.ok((ref.content.match(/^### /gm) || []).length <= MAX_REATTACH_FILES, 'attachment file count must stay capped');
-  assert.ok(estimateTokens(ref.content) <= REATTACH_MAX_TOTAL_TOKENS, 'attachment total tokens must stay capped');
-}
-rmSync(dir, { recursive: true, force: true });
-console.log('compact file-reattach test passed \u2713');
-