mixdog 0.9.151 → 0.9.153

package/src/runtime/office/com-adapter.mjs

@@ -0,0 +1,283 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { fileURLToPath } from 'node:url';
+
+export function resolveMicrosoftOfficeHostScriptPath(scriptPath) {
+  return scriptPath.replace(/([\\/][^\\/]+\.asar)([\\/])/i, '$1.unpacked$2');
+}
+
+const HOST_SCRIPT = resolveMicrosoftOfficeHostScriptPath(
+  fileURLToPath(new URL('./office-com-host.ps1', import.meta.url)),
+);
+const SESSION_HOST_SCRIPT = resolveMicrosoftOfficeHostScriptPath(
+  fileURLToPath(new URL('./office-com-session-host.ps1', import.meta.url)),
+);
+const DEFAULT_TIMEOUT_MS = 90_000;
+const sessionClients = new Map();
+let nextRequestId = 1;
+
+function powershellProgram() {
+  return process.env.SystemRoot
+    ? `${process.env.SystemRoot}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`
+    : 'powershell.exe';
+}
+
+export function microsoftOfficeComSupported() {
+  return process.platform === 'win32';
+}
+
+function spawnPowerShell(script) {
+  return spawn(powershellProgram(), [
+    '-NoLogo',
+    '-NoProfile',
+    '-NonInteractive',
+    '-Sta',
+    '-ExecutionPolicy',
+    'Bypass',
+    '-File',
+    script,
+  ], {
+    windowsHide: true,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+}
+
+async function callMicrosoftOfficeOnce(payload, {
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  signal = null,
+} = {}) {
+  return await new Promise((resolve) => {
+    const child = spawnPowerShell(HOST_SCRIPT);
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener?.('abort', onAbort);
+      resolve(value);
+    };
+    const onAbort = () => {
+      try { child.kill(); } catch {}
+      finish({ ok: false, cancelled: true, error: 'Microsoft Office operation was cancelled' });
+    };
+    const timer = setTimeout(() => {
+      try { child.kill(); } catch {}
+      finish({ ok: false, error: `Microsoft Office operation timed out after ${timeoutMs}ms` });
+    }, timeoutMs);
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+    child.on('error', (error) => finish({ ok: false, error: error?.message || String(error) }));
+    child.on('close', (code) => {
+      if (settled) return;
+      const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+      const last = lines.at(-1) || '';
+      try {
+        const parsed = JSON.parse(last);
+        finish(parsed);
+      } catch {
+        finish({
+          ok: false,
+          error: stderr.trim() || last || `Microsoft Office host exited with code ${code}`,
+        });
+      }
+    });
+    if (signal?.aborted) return onAbort();
+    signal?.addEventListener?.('abort', onAbort, { once: true });
+    child.stdin.end(JSON.stringify(payload ?? {}), 'utf8');
+  });
+}
+
+function stopSessionClient(client, error = '') {
+  if (!client || client.closed) return;
+  client.closed = true;
+  sessionClients.delete(client.sessionId);
+  const failure = {
+    ok: false,
+    backend: 'microsoft-office-com',
+    error: error || 'Microsoft Office session host stopped',
+  };
+  for (const pending of client.pending.values()) {
+    clearTimeout(pending.timer);
+    pending.resolve(failure);
+  }
+  client.pending.clear();
+  try { client.readline.close(); } catch {}
+  try { client.child.stdin.end(); } catch {}
+  try { client.child.kill(); } catch {}
+  if (client.ownership === 'owned' && Number(client.appPid) > 0) {
+    try { process.kill(Number(client.appPid)); } catch {}
+  }
+}
+
+function createSessionClient(sessionId) {
+  const child = spawnPowerShell(SESSION_HOST_SCRIPT);
+  child.unref();
+  child.stdin.unref?.();
+  child.stdout.unref?.();
+  child.stderr.unref?.();
+  const client = {
+    sessionId,
+    child,
+    pending: new Map(),
+    stderr: '',
+    closed: false,
+    readline: createInterface({ input: child.stdout }),
+  };
+  client.readline.on('line', (line) => {
+    const text = String(line || '').trim();
+    if (!text) return;
+    let message;
+    try {
+      message = JSON.parse(text);
+    } catch {
+      return;
+    }
+    const requestId = String(message.requestId || '');
+    const pending = client.pending.get(requestId);
+    if (!pending) return;
+    client.pending.delete(requestId);
+    clearTimeout(pending.timer);
+    delete message.requestId;
+    pending.resolve(message);
+  });
+  child.stderr.setEncoding('utf8');
+  child.stderr.on('data', (chunk) => {
+    client.stderr = `${client.stderr}${chunk}`.slice(-16_000);
+  });
+  child.on('error', (error) => stopSessionClient(client, error?.message || String(error)));
+  child.on('close', (code) => {
+    if (client.closed) return;
+    stopSessionClient(
+      client,
+      client.stderr.trim() || `Microsoft Office session host exited with code ${code}`,
+    );
+  });
+  sessionClients.set(sessionId, client);
+  return client;
+}
+
+async function requestSessionClient(client, payload, timeoutMs = DEFAULT_TIMEOUT_MS, signal = null) {
+  if (!client || client.closed) {
+    return { ok: false, backend: 'microsoft-office-com', error: 'Microsoft Office session host is unavailable' };
+  }
+  const requestId = `office_request_${nextRequestId++}`;
+  return await new Promise((resolve) => {
+    const settle = (value) => {
+      signal?.removeEventListener?.('abort', onAbort);
+      resolve(value);
+    };
+    const onAbort = () => {
+      client.pending.delete(requestId);
+      clearTimeout(timer);
+      settle({ ok: false, backend: 'microsoft-office-com', cancelled: true, error: 'Microsoft Office operation was cancelled' });
+      stopSessionClient(client, 'Microsoft Office operation was cancelled');
+    };
+    const timer = setTimeout(() => {
+      client.pending.delete(requestId);
+      settle({
+        ok: false,
+        backend: 'microsoft-office-com',
+        error: `Microsoft Office operation timed out after ${timeoutMs}ms`,
+      });
+      stopSessionClient(client, `Microsoft Office session timed out after ${timeoutMs}ms`);
+    }, timeoutMs);
+    if (signal?.aborted) return onAbort();
+    signal?.addEventListener?.('abort', onAbort, { once: true });
+    client.pending.set(requestId, { resolve: settle, timer });
+    try {
+      client.child.stdin.write(`${JSON.stringify({ ...payload, requestId })}\n`, 'utf8');
+    } catch (error) {
+      clearTimeout(timer);
+      client.pending.delete(requestId);
+      settle({ ok: false, backend: 'microsoft-office-com', error: error?.message || String(error) });
+      stopSessionClient(client, error?.message || String(error));
+    }
+  });
+}
+
+export async function openMicrosoftOfficeSession(payload, {
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  signal = null,
+} = {}) {
+  if (!microsoftOfficeComSupported()) {
+    return { ok: false, available: false, error: 'Microsoft Office COM is available on Windows only' };
+  }
+  const sessionId = String(payload?.session || '');
+  if (!sessionId) return { ok: false, error: 'Microsoft Office session id is required' };
+  if (sessionClients.has(sessionId)) return { ok: false, error: `Microsoft Office session already exists: ${sessionId}` };
+  const client = createSessionClient(sessionId);
+  const result = await requestSessionClient(client, { ...payload, action: 'open_session' }, timeoutMs, signal);
+  if (!result.ok) {
+    stopSessionClient(client, result.error);
+  } else {
+    client.ownership = result.ownership;
+    client.appPid = result.appPid;
+  }
+  return result;
+}
+
+export async function closeMicrosoftOfficeSession(sessionId, {
+  save = false,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  closeTimeoutMs = 15_000,
+  signal = null,
+} = {}) {
+  const client = sessionClients.get(String(sessionId));
+  if (!client) return { ok: true, closed: true, alreadyClosed: true };
+  const result = await requestSessionClient(client, {
+    action: 'close_session',
+    session: String(sessionId),
+    save,
+  }, timeoutMs, signal);
+  if (result.ok) {
+    sessionClients.delete(String(sessionId));
+    try { client.child.stdin.end(); } catch {}
+    const graceful = client.closed || client.child.exitCode !== null
+      ? true
+      : await Promise.race([
+        new Promise((resolve) => client.child.once('close', () => resolve(true))),
+        new Promise((resolve) => setTimeout(() => resolve(false), closeTimeoutMs)),
+      ]);
+    client.closed = true;
+    try { client.readline.close(); } catch {}
+    if (!graceful) {
+      try { client.child.kill(); } catch {}
+      if (result.ownership === 'owned' && Number(result.appPid) > 0) {
+        try { process.kill(Number(result.appPid)); } catch {}
+      }
+      result.forcedProcessCleanup = result.ownership === 'owned';
+    }
+  }
+  return result;
+}
+
+export async function callMicrosoftOffice(payload, {
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  signal = null,
+} = {}) {
+  if (!microsoftOfficeComSupported()) {
+    return { ok: false, available: false, error: 'Microsoft Office COM is available on Windows only' };
+  }
+  const sessionId = String(payload?.session || '');
+  if (sessionId) {
+    const client = sessionClients.get(sessionId);
+    if (!client) {
+      return { ok: false, backend: 'microsoft-office-com', error: `Unknown Microsoft Office session: ${sessionId}` };
+    }
+    return await requestSessionClient(client, payload, timeoutMs, signal);
+  }
+  return await callMicrosoftOfficeOnce(payload, { timeoutMs, signal });
+}
+
+export async function detectMicrosoftOffice({ format = '', path = '' } = {}) {
+  return await callMicrosoftOfficeOnce({ action: 'detect', format, path }, { timeoutMs: 20_000 });
+}
+
+export function resetMicrosoftOfficeSessionsForTest() {
+  for (const client of sessionClients.values()) stopSessionClient(client, 'Microsoft Office test reset');
+  sessionClients.clear();
+}

package/src/runtime/office/content-model.mjs

@@ -0,0 +1,183 @@
+import { createHash } from 'node:crypto';
+
+function plainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function clone(value) {
+  return value == null ? value : JSON.parse(JSON.stringify(value));
+}
+
+function stableValue(value) {
+  if (Array.isArray(value)) return value.map(stableValue);
+  if (!plainObject(value)) return value;
+  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stableValue(value[key])]));
+}
+
+function safeId(value, label) {
+  const normalized = String(value || '').trim().toLowerCase();
+  if (!/^[a-z0-9][a-z0-9._-]{0,63}$/.test(normalized)) {
+    throw new Error(`Office content ${label} must use 1-64 lowercase letters, digits, dots, underscores, or hyphens`);
+  }
+  return normalized;
+}
+
+function normalizeSource(value) {
+  if (typeof value === 'string') return value.trim();
+  if (!plainObject(value)) return null;
+  const document = String(value.document || '').trim();
+  if (!document) return null;
+  return {
+    document,
+    ...(value.target ? { target: String(value.target) } : {}),
+    ...(value.label ? { label: String(value.label) } : {}),
+  };
+}
+
+function sourceText(value) {
+  if (typeof value === 'string') return value;
+  if (!plainObject(value)) return '';
+  const document = String(value.document || '');
+  const target = String(value.target || '');
+  const label = String(value.label || '');
+  return `${document}${target ? `#${target}` : ''}${label ? ` (${label})` : ''}`;
+}
+
+export function normalizeOfficeContentModel(value) {
+  if (value == null) return null;
+  if (!plainObject(value)) throw new Error('Office design.content must be an object');
+  const rawFacts = Array.isArray(value.facts) ? value.facts : [];
+  const rawClaims = Array.isArray(value.claims) ? value.claims : [];
+  if (rawFacts.length > 1_000 || rawClaims.length > 500) {
+    throw new Error('Office content model exceeds the supported fact or claim count');
+  }
+  const factIds = new Set();
+  const facts = rawFacts.map((fact) => {
+    if (!plainObject(fact)) throw new Error('Office content facts must be objects');
+    const id = safeId(fact.id, 'fact id');
+    if (factIds.has(id)) throw new Error(`Office content model has duplicate fact id ${id}`);
+    factIds.add(id);
+    return {
+      id,
+      label: String(fact.label || id),
+      value: clone(fact.value),
+      ...(fact.unit ? { unit: String(fact.unit) } : {}),
+      ...(fact.detail ? { detail: String(fact.detail) } : {}),
+      ...(fact.numberFormat ? { numberFormat: String(fact.numberFormat) } : {}),
+      ...(normalizeSource(fact.source) ? { source: normalizeSource(fact.source) } : {}),
+    };
+  });
+  const claimIds = new Set();
+  const claims = rawClaims.map((claim) => {
+    if (!plainObject(claim)) throw new Error('Office content claims must be objects');
+    const id = safeId(claim.id, 'claim id');
+    if (claimIds.has(id)) throw new Error(`Office content model has duplicate claim id ${id}`);
+    claimIds.add(id);
+    const factRefs = [...new Set((Array.isArray(claim.factIds) ? claim.factIds : [])
+      .map((entry) => safeId(entry, `claim ${id} fact reference`)))];
+    for (const factId of factRefs) {
+      if (!factIds.has(factId)) throw new Error(`Office content claim ${id} references unknown fact ${factId}`);
+    }
+    return {
+      id,
+      text: String(claim.text || '').trim(),
+      factIds: factRefs,
+      ...(claim.implication ? { implication: String(claim.implication) } : {}),
+    };
+  });
+  const normalized = {
+    packageId: value.packageId ? safeId(value.packageId, 'package id') : '',
+    audience: String(value.audience || ''),
+    objective: String(value.objective || ''),
+    decision: String(value.decision || ''),
+    period: String(value.period || ''),
+    facts,
+    claims,
+  };
+  normalized.fingerprint = createHash('sha256')
+    .update(JSON.stringify(stableValue(normalized)))
+    .digest('hex');
+  return normalized;
+}
+
+export function summarizeOfficeContentModel(model) {
+  if (!model) return null;
+  return {
+    packageId: model.packageId,
+    fingerprint: model.fingerprint,
+    audience: model.audience,
+    objective: model.objective,
+    decision: model.decision,
+    period: model.period,
+    factCount: model.facts.length,
+    claimCount: model.claims.length,
+    sourcedFactCount: model.facts.filter((fact) => fact.source).length,
+  };
+}
+
+export function bindOfficeContent(operation, model) {
+  if (!model || !plainObject(operation)) return { operation, binding: null };
+  const facts = new Map(model.facts.map((fact) => [fact.id, fact]));
+  const claims = new Map(model.claims.map((claim) => [claim.id, claim]));
+  const used = new Set();
+  const fact = (id) => {
+    const normalized = safeId(id, 'fact reference');
+    const resolved = facts.get(normalized);
+    if (!resolved) throw new Error(`Office semantic operation references unknown fact ${normalized}`);
+    used.add(normalized);
+    return resolved;
+  };
+  const resolveValue = (entry) => {
+    if (Array.isArray(entry)) return entry.map(resolveValue);
+    if (!plainObject(entry)) return entry;
+    if (entry.factId) {
+      const resolved = fact(entry.factId);
+      const field = String(entry.field || 'value');
+      if (!Object.hasOwn(resolved, field)) throw new Error(`Office fact ${resolved.id} has no field ${field}`);
+      return clone(resolved[field]);
+    }
+    return Object.fromEntries(Object.entries(entry).map(([key, child]) => [key, resolveValue(child)]));
+  };
+  const bound = clone(operation);
+  if (bound.claimId) {
+    const claimId = safeId(bound.claimId, 'claim reference');
+    const claim = claims.get(claimId);
+    if (!claim) throw new Error(`Office semantic operation references unknown claim ${claimId}`);
+    for (const factId of claim.factIds) used.add(factId);
+    if (!bound.title) bound.title = claim.text;
+    if (!bound.takeaway) bound.takeaway = claim.implication || claim.text;
+  }
+  if (Array.isArray(bound.metrics)) {
+    bound.metrics = bound.metrics.map((metric) => {
+      if (!plainObject(metric) || !metric.factId) return resolveValue(metric);
+      const resolved = fact(metric.factId);
+      return {
+        ...metric,
+        value: metric.value ?? clone(resolved.value),
+        label: metric.label || resolved.label,
+        detail: metric.detail || resolved.detail || resolved.unit || '',
+        numberFormat: metric.numberFormat || resolved.numberFormat || '',
+      };
+    });
+  }
+  for (const key of ['rows', 'table', 'chart', 'columns', 'steps']) {
+    if (bound[key] != null) bound[key] = resolveValue(bound[key]);
+  }
+  const sources = [...used]
+    .map((id) => facts.get(id)?.source)
+    .filter(Boolean)
+    .map(sourceText)
+    .filter((entry, index, values) => values.indexOf(entry) === index);
+  if (!bound.source && sources.length) bound.source = sources.join('; ');
+  return {
+    operation: bound,
+    binding: {
+      packageId: model.packageId,
+      contentFingerprint: model.fingerprint,
+      claimId: bound.claimId ? String(bound.claimId).toLowerCase() : '',
+      factIds: [...used].sort(),
+      sources,
+    },
+  };
+}
+

package/src/runtime/office/contract-benchmark.mjs

@@ -0,0 +1,105 @@
+import assert from 'node:assert/strict';
+import { pathToFileURL } from 'node:url';
+
+import { executeOfficeTool } from './index.mjs';
+
+const CASES = [
+  {
+    format: 'docx',
+    backend: 'mixdog-ooxml',
+    operation: 'append_text',
+    required: ['op', 'text'],
+  },
+  {
+    format: 'xlsx',
+    backend: 'microsoft-office-com',
+    operation: 'add_chart',
+    required: ['op', 'range'],
+  },
+  {
+    format: 'pptx',
+    backend: 'microsoft-office-com',
+    operation: 'add_textbox',
+    required: ['op', 'slide', 'text'],
+  },
+  {
+    format: 'pdf',
+    backend: 'mixdog-pdf',
+    operation: 'add_text',
+    required: ['op', 'text'],
+  },
+];
+
+function resultValue(result) {
+  const text = result?.content?.[0]?.text || '';
+  if (result?.isError) throw new Error(text);
+  return JSON.parse(text);
+}
+
+export async function runOfficeContractBenchmark() {
+  let deterministicToolCalls = 0;
+  const call = async (input) => {
+    deterministicToolCalls += 1;
+    return executeOfficeTool(input);
+  };
+
+  const summary = resultValue(await call({ action: 'describe' }));
+  assert.equal(summary.actions.length, 23);
+  for (const removed of ['set', 'add', 'remove', 'move']) assert.equal(summary.actions.includes(removed), false);
+  for (const entry of Object.values(summary.formats)) {
+    assert.equal(entry.operations, undefined);
+    assert.ok(entry.operationCount > 0);
+  }
+
+  const results = [];
+  for (const scenario of CASES) {
+    const described = resultValue(await call({ action: 'describe', ...scenario }));
+    assert.equal(described.operation.name, scenario.operation);
+    assert.equal(described.operation.supported, true);
+    assert.deepEqual(described.operation.input.required, scenario.required);
+    results.push({
+      format: scenario.format,
+      backend: scenario.backend,
+      operation: scenario.operation,
+      responseChars: JSON.stringify(described).length,
+      accurate: true,
+    });
+  }
+
+  const invalid = await call({
+    action: 'describe',
+    format: 'xlsx',
+    operation: 'add_chrt',
+  });
+  assert.equal(invalid.isError, true);
+  const invalidError = invalid.content?.[0]?.text || '';
+  assert.match(invalidError, /Did you mean: add_chart/);
+  assert.match(invalidError, /describe/);
+
+  return {
+    version: 2,
+    createdAt: new Date().toISOString(),
+    measurementKind: 'deterministic-contract-probe',
+    modelBehaviorMeasured: false,
+    deterministicToolCalls,
+    retries: 0,
+    unnecessaryRereads: 0,
+    broadCatalogMaterializations: 0,
+    publicActionCount: summary.actions.length,
+    requirementFulfillment: {
+      passed: results.length,
+      total: CASES.length,
+      rate: results.length / CASES.length,
+    },
+    summaryResponseChars: JSON.stringify(summary).length,
+    maxTargetedResponseChars: Math.max(...results.map((entry) => entry.responseChars)),
+    actionableErrorProbe: true,
+    accurate: results.every((entry) => entry.accurate),
+    results,
+  };
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const report = await runOfficeContractBenchmark();
+  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+}