@geraldmaron/construct 1.2.2 → 1.3.0

package/lib/chat/desktop-launcher.mjs

@@ -1,133 +0,0 @@
-/**
- * lib/chat/desktop-launcher.mjs — start dashboard and open Construct chat in the native window.
- *
- * Launch order when the construct-chat binary is missing: build it from the Tauri
- * source on disk (dev/branch path), else download the prebuilt release asset, else
- * fail loudly with remediation. Chrome app-mode is never an implicit substitute —
- * the native window is the contract, and `construct chat --web` is the explicit
- * browser path.
- */
-
-import { spawn } from 'node:child_process';
-import os from 'node:os';
-import { startDashboard, readDashboardState } from '../service-manager.mjs';
-import { hasGuiDisplay, resolveDesktopBinary } from './desktop-binary.mjs';
-import { buildDesktopBinary, hasDesktopSource } from './desktop-build.mjs';
-
-async function ensureDashboard({ cwd, env, errorOutput }) {
-  let dash = readDashboardState();
-  if (dash?.port) return dash;
-
-  const result = await startDashboard({
-    rootDir: cwd,
-    preferredPort: parseInt(env.PORT || env.DASHBOARD_PORT || '4242', 10),
-  });
-  if (result.started || result.reused) {
-    return { port: result.port, url: result.url || `http://127.0.0.1:${result.port}` };
-  }
-  errorOutput.write(`Failed to start dashboard: ${result.reason || 'unknown error'}\n`);
-  return null;
-}
-
-function waitForChild(child) {
-  return new Promise((resolve) => {
-    let settled = false;
-    const finish = (code) => {
-      if (settled) return;
-      settled = true;
-      resolve(code ?? 0);
-    };
-
-    if (child) {
-      child.on('exit', (code) => finish(code));
-      child.on('error', () => finish(1));
-    }
-
-    const onSignal = () => {
-      try { child?.kill('SIGTERM'); } catch { /* already exited */ }
-      finish(0);
-    };
-    process.once('SIGINT', onSignal);
-    process.once('SIGTERM', onSignal);
-
-    if (!child) finish(0);
-  });
-}
-
-function spawnDesktopBinary(bin, chatUrl, env) {
-  if (/\.(mjs|cjs|js)$/i.test(bin)) {
-    return spawn(process.execPath, [bin, '--url', chatUrl], {
-      env: { ...env, CONSTRUCT_CHAT_URL: chatUrl },
-      stdio: 'ignore',
-      detached: false,
-    });
-  }
-  return spawn(bin, ['--url', chatUrl], {
-    env: { ...env, CONSTRUCT_CHAT_URL: chatUrl },
-    stdio: 'ignore',
-    detached: false,
-  });
-}
-
-async function tryDownloadBinary(env) {
-  try {
-    const { downloadDesktopBinary } = await import('../install/desktop-binary-download.mjs');
-    const result = await downloadDesktopBinary({ homeDir: os.homedir(), env });
-    if (result.status === 'downloaded') return resolveDesktopBinary();
-  } catch {
-    /* fall through to loud failure below */
-  }
-  return null;
-}
-
-function resolveBinaryToLaunch({ cwd, env, output, errorOutput }) {
-  const existing = resolveDesktopBinary({ repoRoot: cwd, env });
-  if (existing) return existing;
-
-  if (hasDesktopSource(cwd)) {
-    const built = buildDesktopBinary({ repoRoot: cwd, env, output, errorOutput });
-    if (built.ok) return built.binaryPath;
-    errorOutput.write(`Could not build the Construct Chat window: ${built.reason}\n`);
-    return null;
-  }
-
-  return null;
-}
-
-export async function runDesktopChat({
-  cwd = process.cwd(),
-  env = process.env,
-  output = process.stdout,
-  errorOutput = process.stderr,
-  binaryPath = null,
-  dashOverride = null,
-} = {}) {
-  if (!hasGuiDisplay(env)) {
-    errorOutput.write('No graphical display available. Use `construct chat --plain` for terminal mode.\n');
-    return 1;
-  }
-
-  let bin = binaryPath || resolveBinaryToLaunch({ cwd, env, output, errorOutput });
-
-  if (!bin && !hasDesktopSource(cwd)) {
-    bin = await tryDownloadBinary(env);
-  }
-
-  if (!bin) {
-    errorOutput.write(
-      'The Construct Chat native window is unavailable.\n'
-      + 'Build it with: npm run build:chat-desktop (requires the Rust toolchain from https://rustup.rs)\n'
-      + 'Or open chat in a browser tab with: construct chat --web\n',
-    );
-    return 1;
-  }
-
-  const dash = dashOverride || await ensureDashboard({ cwd, env, errorOutput });
-  if (!dash) return 1;
-
-  const base = (dash.url || `http://127.0.0.1:${dash.port}`).replace(/\/$/, '');
-  const chatUrl = `${base}/chat/?surface=desktop`;
-
-  const child = spawnDesktopBinary(bin, chatUrl, env);
-  return waitForChild(child);
-}

package/lib/chat/evidence.mjs

@@ -1,145 +0,0 @@
-/** Per-turn evidence provenance for chat surfaces. */
-
-export const EVIDENCE_SCHEMA_VERSION = 1;
-
-const REPO_EVIDENCE_TOOLS = new Set(['read', 'grep', 'glob']);
-const GLOB_META_RE = /[*?\[\]{}]/;
-
-function freeze(value) {
-  if (Array.isArray(value)) value.forEach(freeze);
-  else if (value && typeof value === 'object') Object.values(value).forEach(freeze);
-  return Object.freeze(value);
-}
-
-function concreteTarget(value) {
-  if (typeof value !== 'string' || !value.trim() || GLOB_META_RE.test(value)) return null;
-  return value;
-}
-
-function toolResult(tool = {}) {
-  const result = tool.content ?? tool.result;
-  return result && typeof result === 'object' ? result : null;
-}
-
-function concreteTargets(tool = {}) {
-  const result = toolResult(tool);
-  const name = String(tool.title || tool.kind || '');
-  if (!result) return [];
-  if (name === 'read') return [concreteTarget(result.path || tool.input?.path)].filter(Boolean);
-
-  // grep/glob requests describe a search, not a source. Only the concrete files
-  // returned by a successful result become evidence records.
-  const matches = Array.isArray(result.matches) ? result.matches : [];
-  return [...new Set(matches.map((match) => concreteTarget(typeof match === 'string' ? match : match?.file || match?.path)).filter(Boolean))];
-}
-
-export function evidenceTarget(tool = {}) {
-  return concreteTargets(tool)[0] || null;
-}
-
-export function isSuccessfulEvidenceTool(tool = {}) {
-  if (!REPO_EVIDENCE_TOOLS.has(String(tool.title || tool.kind || ''))) return false;
-  if (tool.status !== 'completed') return false;
-  const result = toolResult(tool);
-  return Boolean(result && result.ok !== false && result.denied !== true && !result.error && concreteTargets(tool).length);
-}
-
-export function evidenceRecords(tools = [], { turnId = null } = {}) {
-  const records = [];
-  for (const tool of tools) {
-    if (!isSuccessfulEvidenceTool(tool)) continue;
-    for (const target of concreteTargets(tool)) {
-      records.push(freeze({
-        schemaVersion: EVIDENCE_SCHEMA_VERSION,
-        recordId: `${turnId || 'turn'}:${String(tool.id || '')}:${target}`,
-        turnId: turnId ? String(turnId) : null,
-        toolId: String(tool.id || ''),
-        tool: String(tool.title || tool.kind),
-        requestedTarget: String(tool.input?.path || tool.input?.glob || tool.input?.pattern || ''),
-        target,
-        sourceId: `repo:${target}`,
-        completion: 'completed',
-        result: 'success',
-      }));
-    }
-  }
-  return freeze(records);
-}
-
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-export function citationMatches(text, record) {
-  const target = String(record?.target || '');
-  const sourceId = String(record?.sourceId || '');
-  if (!target) return false;
-  const escapedTarget = escapeRegExp(target);
-  const targetPattern = new RegExp(`(^|[^A-Za-z0-9_./-])${escapedTarget}(?=$|[^A-Za-z0-9_./-])`);
-  const sourcePattern = sourceId
-    ? new RegExp(`\\[source:\\s*${escapeRegExp(sourceId)}\\s*\\]`, 'i')
-    : null;
-  return targetPattern.test(text) || Boolean(sourcePattern?.test(text));
-}
-
-function verdict({ status, records = [], citations = [], reasonCodes = [] }) {
-  return freeze({
-    schemaVersion: EVIDENCE_SCHEMA_VERSION,
-    status,
-    records: [...records],
-    citations: [...new Set(citations)],
-    reasonCodes: [...reasonCodes],
-  });
-}
-
-export function deriveEvidenceVerdict({ id = null, overlay = null, tools = [], assistant = '', evidenceVisible = true, migration = false } = {}) {
-  const required = overlay?.assumptionsBlocked || overlay?.externalResearch?.required;
-  const migrationCode = migration ? ['legacy_snapshot_without_evidence'] : [];
-  if (!required) return verdict({ status: 'not_applicable', reasonCodes: ['evidence_not_required', ...migrationCode] });
-  if (!evidenceVisible) return verdict({ status: 'insufficient_evidence', reasonCodes: ['evidence_layer_hidden', ...migrationCode] });
-
-  const records = evidenceRecords(tools, { turnId: id });
-  if (!records.length) return verdict({ status: 'insufficient_evidence', records, reasonCodes: ['no_successful_concrete_evidence', ...migrationCode] });
-  const text = String(assistant || '');
-  const citations = records.filter((record) => citationMatches(text, record)).map((record) => record.target);
-  if (!citations.length) return verdict({ status: 'uncited_evidence', records, citations, reasonCodes: ['evidence_not_cited', ...migrationCode] });
-  return verdict({
-    status: citations.length === records.length ? 'verified' : 'partially_verified',
-    records,
-    citations,
-    reasonCodes: [citations.length === records.length ? 'all_recorded_evidence_cited' : 'some_recorded_evidence_uncited', ...migrationCode],
-  });
-}
-
-export function migrateEvidenceVerdict(turn = {}) {
-  if (turn.evidence?.schemaVersion === EVIDENCE_SCHEMA_VERSION) return turn.evidence;
-  if (turn.evidence?.status) {
-    const records = (turn.evidence.records || []).map((record, index) => freeze({
-      schemaVersion: EVIDENCE_SCHEMA_VERSION,
-      recordId: record.recordId || `${turn.id || 'turn'}:${record.toolId || ''}:${record.target || index}`,
-      turnId: record.turnId || turn.id || null,
-      toolId: record.toolId || '',
-      tool: record.tool || 'unknown',
-      requestedTarget: record.requestedTarget || record.target || '',
-      target: record.target || '',
-      sourceId: record.sourceId || `repo:${record.target || ''}`,
-      completion: record.completion || 'completed',
-      result: record.result || 'success',
-    })).filter((record) => record.target);
-    return verdict({
-      status: turn.evidence.status,
-      records,
-      citations: turn.evidence.citations || [],
-      reasonCodes: [...(turn.evidence.reasonCodes || []), 'legacy_evidence_unversioned'],
-    });
-  }
-  return deriveEvidenceVerdict({ ...turn, migration: true });
-}
-
-export function evidenceNotice(verdict) {
-  if (!verdict || verdict.status === 'not_applicable' || verdict.status === 'verified') return null;
-  if (verdict.reasonCodes?.includes('evidence_layer_hidden')) return 'Evidence tools were hidden for this turn, so no source was verified';
-  if (verdict.status === 'uncited_evidence') return 'Evidence was read but the answer does not cite its recorded paths — treat claims as unverified';
-  if (verdict.status === 'partially_verified') return 'Only some recorded evidence paths are cited — treat uncited claims as unverified';
-  return 'Answer produced without successful recorded repo evidence — treat as unverified';
-}

package/lib/chat/export.mjs

@@ -1,74 +0,0 @@
-/**
- * lib/chat/export.mjs — plain markdown export for construct chat turns.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import { resolveProjectScopedPath } from '../project-root.mjs';
-import { summarizeSources } from './tui/turn-present.mjs';
-import { rehydrateContinuation } from './context-continuation.mjs';
-import { createContinuationResolver } from './continuation-source.mjs';
-
-function exportDir({ cwd }) {
-  const base = resolveProjectScopedPath('chat-sessions', { cwd, ensureDir: true });
-  const dir = path.join(base, 'exports');
-  fs.mkdirSync(dir, { recursive: true });
-  return dir;
-}
-
-// Render a persisted continuation packet by rehydrating it through the one shared
-// resolver (AC3): reconstructible layers re-derive via the same composer a live
-// turn runs, elided layers report as summarized, and the budget accounting stays
-// re-verifiable in the export.
-
-function continuationToMarkdown(packet, { cwd }) {
-  if (!packet || typeof packet !== 'object') return '';
-  const resolver = createContinuationResolver({ cwd });
-  const layers = rehydrateContinuation(packet, { resolveSource: resolver.resolveSource });
-  const budget = packet.budget || {};
-  const lines = ['### context continuation', '',
-    `compacted to fit ~${budget.triggerTokens ?? 'n/a'} tokens — retained ${budget.retainedTokens ?? 0}, summarized ${budget.elidedTokens ?? 0}, referenced ${budget.referencedCount ?? 0}`];
-  if (packet.blocker) {
-    lines.push('', `blocker: ${packet.blocker.reason} (required ${packet.blocker.requiredTokens} > budget ${packet.blocker.budgetTokens})`);
-  }
-  const reconstructed = layers.filter((l) => l.sourceId || l.elided);
-  if (reconstructed.length) {
-    lines.push('', 'layers on rehydrate:');
-    for (const layer of reconstructed) {
-      if (layer.elided) lines.push(`- ${layer.kind}: summarized (elided)`);
-      else lines.push(`- ${layer.kind}: ${layer.resolved ? `re-derived from ${layer.sourceId}` : `unresolved (${layer.sourceId})`}`);
-    }
-  }
-  return lines.join('\n');
-}
-
-function turnToMarkdown(turn, { cwd = process.cwd() } = {}) {
-  const lines = [`## you`, '', turn.userText || '', ''];
-  const evidence = turn.evidence || null;
-  if (evidence) lines.push(`evidence: ${evidence.status}${evidence.reasonCodes?.length ? ` (${evidence.reasonCodes.join(', ')})` : ''}`, '');
-  const src = summarizeSources(evidence?.records?.map((record) => ({ tool: record.tool, ref: record.target })) || turn.sources || []);
-  if (src.total) {
-    lines.push(`sources: ${src.refs.join(', ')}`, '');
-  }
-  lines.push('## construct', '', turn.assistant || '(no answer)', '');
-  if (turn.continuation) {
-    const cont = continuationToMarkdown(turn.continuation, { cwd });
-    if (cont) lines.push('', cont, '');
-  }
-  return lines.join('\n');
-}
-
-export function exportTurns(turnBlocks, { scope = 'last', cwd = process.cwd() } = {}) {
-  const turns = turnBlocks.filter((item) => item.kind === 'turn').map((item) => item.block);
-  if (!turns.length) return { ok: false, error: 'no turns to export' };
-
-  let selected = turns;
-  if (scope === 'last') selected = [turns[turns.length - 1]];
-  else if (scope === 'turn' && turns.length) selected = [turns[turns.length - 1]];
-
-  const body = selected.map((turn) => turnToMarkdown(turn, { cwd })).join('\n---\n\n');
-  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
-  const file = path.join(exportDir({ cwd }), `${stamp}-${scope}-answer.md`);
-  fs.writeFileSync(file, `${body}\n`, 'utf8');
-  return { ok: true, path: file, count: selected.length };
-}

package/lib/chat/harness/driver.mjs

@@ -1,91 +0,0 @@
-/**
- * lib/chat/harness/driver.mjs — normalized harness driver contract for the
- * construct terminal chat surface.
- *
- * A driver runs the agent loop and normalizes its streaming output into one event
- * model, so the transparency engine and the TUI never depend on how the loop is
- * produced. ADR-0041: Construct's owned loop (apps/chat/engine) implements this
- * contract; the union stays the stable seam between the engine and the renderers.
- * Every driver exposes the same shape:
- *   start()             opens a session and returns { sessionId, capabilities }
- *   prompt(text, opts)  async-iterable of normalized events for one turn; opts may
- *                       carry { model, sandbox, permissionMode } when the host supports them
- *   cancel()            aborts the active turn
- *   stop()              tears down the host process / connection
- *   listModels()        optional: returns [{ id, label, ... }] when the host can enumerate models
- *
- * Normalized event union consumed by the rest of the surface:
- *   { type: 'thinking',    text, messageId }      agent internal reasoning chunk
- *   { type: 'text',        text, messageId }      agent message chunk
- *   { type: 'plan',        entries }              planned path / task entries
- *   { type: 'tool_call',   id, title, kind, status }
- *   { type: 'tool_update', id, status, content }
- *   { type: 'usage',       tokens, cost, context, model }
- *                          tokens: { input, output, cacheRead, cacheWrite, reasoning, total }
- *                          cost:   { amount, currency }  context: { used, size }
- *                          every field optional — adapters emit only what the host
- *                          reports (no fabricated splits)
- *   { type: 'specialist',  role, status, detail } construct orchestration overlay
- *   { type: 'permission',  requestId, toolCall, options }
- *   { type: 'notice',      level, code, message } surface-visible advisory (e.g. context-pressure)
- *   { type: 'context_continuation', packet, compacted } persisted continuation packet (construct-6zga.1.10)
- *   { type: 'error',       message }
- *   { type: 'done',        stopReason }
- *
- * Keeping this union stable is what lets ACP agents and per-host adapters be
- * swapped without touching the transparency or rendering layers.
- */
-
-export const EVENT_TYPES = Object.freeze({
-  THINKING: 'thinking',
-  TEXT: 'text',
-  PLAN: 'plan',
-  TOOL_CALL: 'tool_call',
-  TOOL_UPDATE: 'tool_update',
-  USAGE: 'usage',
-  SPECIALIST: 'specialist',
-  PERMISSION: 'permission',
-  NOTICE: 'notice',
-  CONTEXT_CONTINUATION: 'context_continuation',
-  ERROR: 'error',
-  DONE: 'done',
-});
-
-// A single-producer/single-consumer queue that is also an async iterable. The
-// line-router pushes normalized events as they arrive; the turn loop awaits them
-// until the producer closes the queue on stop reason or error.
-
-export class AsyncEventQueue {
-  constructor() {
-    this.buffer = [];
-    this.waiters = [];
-    this.closed = false;
-  }
-
-  push(value) {
-    if (this.closed) return;
-    const waiter = this.waiters.shift();
-    if (waiter) waiter({ value, done: false });
-    else this.buffer.push(value);
-  }
-
-  close() {
-    if (this.closed) return;
-    this.closed = true;
-    while (this.waiters.length) this.waiters.shift()({ value: undefined, done: true });
-  }
-
-  [Symbol.asyncIterator]() {
-    return {
-      next: () => {
-        if (this.buffer.length) return Promise.resolve({ value: this.buffer.shift(), done: false });
-        if (this.closed) return Promise.resolve({ value: undefined, done: true });
-        return new Promise((resolve) => this.waiters.push(resolve));
-      },
-      return: () => {
-        this.close();
-        return Promise.resolve({ value: undefined, done: true });
-      },
-    };
-  }
-}

package/lib/chat/list-picker.mjs

@@ -1,112 +0,0 @@
-/**
- * lib/chat/list-picker.mjs — searchable list picker for construct chat Ink.
- *
- * Pure state/helpers for arrow-key overlays: type-to-filter, windowed viewport,
- * and selection index clamping for model, setting, and permission pickers.
- */
-
-export function filterPickerItems(items = [], query = '') {
-  const q = String(query || '').trim().toLowerCase();
-  if (!q) return items;
-  return items.filter((item) => {
-    const hay = [item.id, item.label, item.detail, item.tag]
-      .filter(Boolean)
-      .join(' ')
-      .toLowerCase();
-    return hay.includes(q);
-  });
-}
-
-export function pickerStartIndex(items, selectedId, idKey = 'id') {
-  if (!items?.length) return 0;
-  const idx = items.findIndex((item) => item[idKey] === selectedId);
-  if (idx >= 0 && !items[idx]?.disabled) return idx;
-  const firstEnabled = items.findIndex((item) => !item.disabled);
-  if (firstEnabled >= 0) return firstEnabled;
-  return idx >= 0 ? idx : 0;
-}
-
-export function windowPickerItems(items, index, windowSize = 12) {
-  if (!items?.length) return { items: [], offset: 0 };
-  const size = Math.max(5, windowSize);
-  let start = Math.max(0, index - Math.floor(size / 2));
-  if (start + size > items.length) start = Math.max(0, items.length - size);
-  return { items: items.slice(start, start + size), offset: start };
-}
-
-export function clampPickerIndex(state) {
-  const visible = filterPickerItems(state.items, state.query);
-  const max = Math.max(0, visible.length - 1);
-  return { ...state, index: Math.min(state.index, max) };
-}
-
-/**
- * @param {{
- *   kind?: string,
- *   title?: string,
- *   items?: Array<Record<string, unknown>>,
- *   selectedId?: string | null,
- *   context?: string | null,
- *   query?: string,
- * }} [opts]
- */
-export function createListPickerState({
-  kind, title, items, selectedId = null, context = null, query = '',
-} = {}) {
-  const visible = filterPickerItems(items, query);
-  return {
-    kind,
-    title,
-    items,
-    query,
-    index: pickerStartIndex(visible, selectedId),
-    context,
-  };
-}
-
-export function getPickerVisibleItems(state) {
-  return filterPickerItems(state?.items || [], state?.query || '');
-}
-
-export function getPickerSelectedItem(state) {
-  const visible = getPickerVisibleItems(state);
-  return visible[state?.index ?? 0] || null;
-}
-
-export function movePickerIndex(state, delta) {
-  const visible = getPickerVisibleItems(state);
-  if (!visible.length) return state;
-  let idx = state.index ?? 0;
-  for (let step = 0; step < visible.length; step++) {
-    idx = Math.max(0, Math.min(visible.length - 1, idx + delta));
-    if (!visible[idx]?.disabled) return { ...state, index: idx };
-    if ((delta < 0 && idx === 0) || (delta > 0 && idx === visible.length - 1)) break;
-  }
-  return { ...state, index: idx };
-}
-
-export function appendPickerQuery(state, char) {
-  if (!char) return state;
-  return clampPickerIndex({ ...state, query: `${state.query || ''}${char}`, index: 0 });
-}
-
-export function backspacePickerQuery(state) {
-  return clampPickerIndex({ ...state, query: (state.query || '').slice(0, -1), index: 0 });
-}
-
-export function reducePickerKey(state, { char, key } = {}) {
-  if (!state) return { state: null, action: 'none' };
-  if (key?.escape) return { state: null, action: 'cancel' };
-  if (key?.return) return { state, action: 'commit' };
-  if (key?.upArrow) return { state: movePickerIndex(state, -1), action: 'none' };
-  if (key?.downArrow) return { state: movePickerIndex(state, 1), action: 'none' };
-  if (key?.backspace || key?.delete) return { state: backspacePickerQuery(state), action: 'none' };
-  if (char && !key?.ctrl && !key?.meta) return { state: appendPickerQuery(state, char), action: 'none' };
-  return { state, action: 'none' };
-}
-
-export function pickerViewport(state, windowSize = 14) {
-  const visible = getPickerVisibleItems(state);
-  const clamped = clampPickerIndex({ ...state, items: visible });
-  return windowPickerItems(visible, clamped.index, windowSize);
-}