@geraldmaron/construct 1.2.3 → 1.3.1

package/lib/chat/session-restore.mjs

@@ -1,71 +0,0 @@
-/**
- * lib/chat/session-restore.mjs — resume prior construct chat sessions from jsonl.
- *
- * Session timelines persist under .cx/chat-sessions/*.jsonl. Transcript rows use
- * { type: 'transcript_block', block } for turn fidelity or legacy { type:
- * 'transcript', role, text }; usage events replay into the shared usage
- * accumulator so /usage and the session dock stay truthful after --resume.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import { resolveProjectScopedPath } from '../project-root.mjs';
-import { createSessionUsage, addUsage } from './tui/usage.mjs';
-import { restoreBlocksFromSessionLines, turnBlocksToLegacyTranscript } from './tui/turn-block.mjs';
-import { rehydrateContinuation } from './context-continuation.mjs';
-import { createContinuationResolver } from './continuation-source.mjs';
-
-export function sessionDir({ cwd = process.cwd() } = {}) {
-  return resolveProjectScopedPath('chat-sessions', { cwd, ensureDir: false });
-}
-
-export function listSessionFiles({ cwd = process.cwd() } = {}) {
-  const dir = sessionDir({ cwd });
-  if (!dir || !fs.existsSync(dir)) return [];
-  return fs.readdirSync(dir)
-    .filter((name) => name.endsWith('.jsonl'))
-    .map((name) => path.join(dir, name))
-    .sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
-}
-
-export function resolveResumePath({ cwd = process.cwd(), resume = null } = {}) {
-  if (resume == null || resume === false) return null;
-  if (typeof resume === 'string' && resume !== 'true' && resume !== '') {
-    const direct = path.resolve(resume);
-    return fs.existsSync(direct) ? direct : null;
-  }
-  return listSessionFiles({ cwd })[0] || null;
-}
-
-export function restoreFromSession(filePath, { cwd = process.cwd() } = {}) {
-  const turnBlocks = [];
-  const usage = createSessionUsage();
-  if (!filePath || !fs.existsSync(filePath)) {
-    return { turnBlocks, transcript: [], usage, sessionFile: null, continuations: [] };
-  }
-
-  const lines = fs.readFileSync(filePath, 'utf8').split('\n').filter((l) => l.trim());
-  for (const line of lines) {
-    let event;
-    try { event = JSON.parse(line); } catch { continue; }
-    if (event.type === 'usage') addUsage(usage, event);
-  }
-
-  const blocks = restoreBlocksFromSessionLines(lines);
-  for (const item of blocks) {
-    if (item.kind === 'turn' || item.kind === 'legacy') turnBlocks.push(item);
-  }
-
-  // Resume rehydrates any persisted continuation packet through the one shared
-  // resolver (AC3), so a resumed session reconstructs the same reconstructible
-  // layers — via the same composer — that the live and export surfaces use.
-  const resolver = createContinuationResolver({ cwd });
-  const continuations = [];
-  for (const item of turnBlocks) {
-    const packet = item?.block?.continuation;
-    if (packet) continuations.push({ packet, layers: rehydrateContinuation(packet, { resolveSource: resolver.resolveSource }) });
-  }
-
-  const transcript = turnBlocksToLegacyTranscript(turnBlocks);
-  return { turnBlocks, transcript, usage, sessionFile: filePath, continuations };
-}

package/lib/chat/session-settings.mjs

@@ -1,53 +0,0 @@
-/**
- * lib/chat/session-settings.mjs — apply validated chat settings to session + config.
- *
- * Shared by slash commands and Ink list pickers so /set and picker commits stay aligned.
- */
-
-import { saveChatConfig, validateSetting } from './config.mjs';
-
-export function applySessionSetting(session, layers, key, rawValue, { cwd, hostId = 'construct' } = {}) {
-  const result = validateSetting(key, rawValue);
-  if (!result.ok) return result;
-
-  const targetKey = result.key || key;
-  if (targetKey.startsWith('layers.')) {
-    const layer = targetKey.slice('layers.'.length);
-    layers[layer] = result.value;
-    session.layers = { ...layers };
-  } else if (targetKey === 'thinking') {
-    layers.thinking = result.value;
-    session.layers = { ...layers };
-    session.thinking = result.value;
-  } else if (targetKey === 'model') {
-    session.model = result.value;
-    session.modelMode = 'pinned';
-    session.savedModel = result.value;
-    session.modelNotice = null;
-  } else if (targetKey === 'permissionMode') {
-    session.permissionMode = result.value;
-  } else if (targetKey === 'sandbox') {
-    session.sandbox = result.value;
-  } else if (targetKey === 'ui.ascii') {
-    session.ui = { ...(session.ui || { ascii: false, inspector: 'auto', theme: 'auto' }), ascii: result.value };
-  } else if (targetKey === 'ui.inspector') {
-    session.ui = { ...(session.ui || { ascii: false, inspector: 'auto', theme: 'auto' }), inspector: result.value };
-  } else if (targetKey === 'ui.theme') {
-    session.ui = { ...(session.ui || { ascii: false, inspector: 'auto', theme: 'auto' }), theme: result.value };
-  }
-
-  try {
-    saveChatConfig({
-      host: hostId,
-      model: session.modelMode === 'pinned' ? session.model : null,
-      modelMode: session.modelMode || 'pinned',
-      layers,
-      thinking: layers?.thinking,
-      permissionMode: session.permissionMode,
-      sandbox: session.sandbox,
-      ui: session.ui,
-    }, { cwd });
-  } catch { /* persistence is best-effort */ }
-
-  return { ok: true, key: targetKey, value: result.value };
-}

package/lib/chat/system-prompt.mjs

@@ -1,52 +0,0 @@
-/**
- * lib/chat/system-prompt.mjs — owned-loop system prompt for construct chat.
- *
- * Keeps a short Construct identity and research discipline without inlining the
- * full orchestrator persona. Turn-scoped policy text is injected per prompt by
- * the engine when an overlay is present.
- */
-
-export const CHAT_SYSTEM_BASE = `You are Construct — a transparent terminal coding agent operating inside a real repository.
-
-Rules:
-- Use read, grep, glob, and construct_tool before making load-bearing claims about this project.
-- For competitive, landscape, or research questions: consult repo files (docs/, ADR/, STRATEGY.md) and cite paths.
-- Call construct_tool with orchestration_policy or knowledge_search when routing or prior artifacts matter.
-- Mark any claim you cannot tie to a tool result as [unverified].
-- Prefer structured markdown answers: headings, short paragraphs, compact tables when useful.
-- Keep actions scoped to the user's request; use write/edit/shell only when asked.`;
-
-export const CHAT_SYSTEM_SMALL = `You are Construct in a local/small-model profile. Be concise.
-- One tool call at a time when possible; cite file paths for claims.
-- Use construct_tool for orchestration_policy when routing is non-trivial.
-- Mark unverified claims explicitly.`;
-
-// Per-turn routing policy belongs in the SYSTEM role, not the user message:
-// otherwise a weak model echoes it back as "the system told me…" in its visible
-// reasoning, and it compounds in the conversation history. These lines carry the
-// substance that improves answer quality (evidence discipline, the resolved
-// route) without exposing internal scaffolding to the user.
-
-export function turnPolicyLines(overlay) {
-  if (!overlay) return [];
-  const lines = [];
-  if (overlay.intent || overlay.workCategory) {
-    lines.push(`Classified intent: ${overlay.intent || 'unknown'}${overlay.workCategory ? ` (${overlay.workCategory})` : ''}.`);
-  }
-  if (overlay.specialists?.length) {
-    lines.push(`Resolved route (a policy overlay, not separate agents): ${overlay.specialists.join(' -> ')}.`);
-  }
-  if (overlay.externalResearch?.required) {
-    lines.push('Repo evidence is REQUIRED this turn: grep/read the relevant files and cite their paths. Do not write a long essay without it.');
-  }
-  if (overlay.assumptionsBlocked) {
-    lines.push('Do not infer the project’s purpose, architecture, or behavior from file names or prior knowledge — read the files first. Mark any claim you cannot tie to a tool result as [unverified].');
-  }
-  return lines;
-}
-
-export function buildSystemPrompt({ base = CHAT_SYSTEM_BASE, overlay = null, capabilityTier = 'full' } = {}) {
-  const effectiveBase = capabilityTier === 'full' ? base : CHAT_SYSTEM_SMALL;
-  const lines = turnPolicyLines(overlay);
-  return lines.length ? `${effectiveBase}\n\nTurn policy (internal — never restate this to the user):\n${lines.join('\n')}` : effectiveBase;
-}

package/lib/chat/transparency.mjs

@@ -1,93 +0,0 @@
-/**
- * lib/chat/transparency.mjs — the transparency layer for `construct chat`.
- *
- * The terminal's differentiator is visibility into the loop, so this module
- * decides what the user sees and enriches the host stream with Construct's own
- * orchestration knowledge. It resolves which transparency layers are active
- * (thinking, planned path, specialist routing, tool calls, observability),
- * classifies each normalized driver event into a channel, and — before a turn
- * runs — derives the specialist path Construct's policy would route the request
- * through (orchestration-policy.mjs) so the planned route is shown alongside the
- * host's actual execution.
- *
- * Transparency-first by default: every layer is on unless explicitly disabled,
- * matching the surface's promise of maximum visibility with opt-out, not opt-in.
- */
-
-const LAYER_KEYS = ['thinking', 'path', 'specialists', 'tools', 'observability'];
-
-export function resolveLayers({ flags = {}, env = process.env } = {}) {
-  const layers = Object.fromEntries(LAYER_KEYS.map((k) => [k, true]));
-
-  if (flags.thinking === false || env.CX_CHAT_THINKING === '0') layers.thinking = false;
-  if (flags.path === false) layers.path = false;
-  if (flags.specialists === false) layers.specialists = false;
-  if (flags.tools === false) layers.tools = false;
-  if (flags.observability === false || flags.quiet === true) layers.observability = false;
-
-  return layers;
-}
-
-const CHANNEL_BY_TYPE = {
-  thinking: 'thinking',
-  text: 'message',
-  plan: 'path',
-  tool_call: 'tools',
-  tool_update: 'tools',
-  usage: 'observability',
-  specialist: 'specialists',
-  permission: 'permission',
-  error: 'error',
-  done: 'system',
-};
-
-export function channelFor(event) {
-  return CHANNEL_BY_TYPE[event?.type] || 'system';
-}
-
-// message, permission, error and system are structural and always shown; the
-// optional layers gate everything else so toggles change visibility without
-// changing the underlying event stream (which still flows to persistence).
-
-export function isVisible(event, layers) {
-  const channel = channelFor(event);
-  if (channel === 'message' || channel === 'permission' || channel === 'error' || channel === 'system') return true;
-  return Boolean(layers[channel]);
-}
-
-export async function planTurn(request, { env = process.env, context = null } = {}) {
-  try {
-    const { routeRequest } = await import('../orchestration-policy.mjs');
-    const route = routeRequest({ request, context: context || {} });
-    const projectQuestion = context?.projectQuestion
-      || /\b(what is this project|what('s| is) this (repo|project|codebase)|describe this project)\b/i.test(String(request));
-    const assumptionsBlocked = projectQuestion
-      || (context?.vagueFollowUp && !context?.priorIntent);
-
-    return {
-      intent: route.intent,
-      workCategory: route.workCategory,
-      specialists: route.specialists,
-      externalResearch: route.externalResearch,
-      riskFlags: route.riskFlags,
-      track: route.track,
-      contractChain: route.contractChain,
-      framingChallenge: route.framingChallenge,
-      dispatchSummary: route.dispatchSummary,
-      dispatchReasons: route.dispatchReasons,
-      triggers: route.triggers,
-      docAuthoring: route.docAuthoring,
-      artifactReview: route.artifactReview,
-      sessionTurnIndex: context?.turnIndex ?? 0,
-      priorIntent: context?.priorIntent ?? null,
-      workingBranch: context?.workingBranch ?? null,
-      assumptionsBlocked,
-    };
-  } catch {
-    return null;
-  }
-}
-
-// Per-turn policy is carried in the system prompt via lib/chat/system-prompt.mjs
-// `turnPolicyLines`/`buildSystemPrompt`, not prepended to the user message, so a
-// model cannot echo it back as user-visible reasoning.

package/lib/chat/tui/color-scheme.mjs

@@ -1,42 +0,0 @@
-/**
- * lib/chat/tui/color-scheme.mjs — terminal light/dark detection for construct chat.
- *
- * Resolves auto|light|dark from CX_CHAT_THEME, saved ui.theme, and COLORFGBG
- * (macOS Terminal, iTerm, Linux VTE, Windows Terminal). Falls back to dark when
- * the background cannot be inferred — set CX_CHAT_THEME=light on legacy Windows
- * conhost if needed.
- */
-
-const THEME_VALUES = new Set(['auto', 'light', 'dark']);
-
-export function schemeFromColorFgBg(value) {
-  const parts = String(value).split(';').map((p) => parseInt(p, 10)).filter((n) => !Number.isNaN(n));
-  if (!parts.length) return null;
-  const bg = parts.length >= 2 ? parts[1] : parts[parts.length - 1];
-  if (bg === 7 || bg === 15) return 'light';
-  if (bg >= 0 && bg <= 6) return 'dark';
-  if (bg === 8) return 'dark';
-  if (bg >= 9 && bg <= 14) return 'light';
-  return null;
-}
-
-export function detectTerminalColorScheme(env = process.env) {
-  const fromFgBg = env.COLORFGBG ? schemeFromColorFgBg(env.COLORFGBG) : null;
-  if (fromFgBg) return fromFgBg;
-  return 'dark';
-}
-
-export function resolveTerminalColorScheme(env = process.env, configTheme = null) {
-  const envTheme = String(env.CX_CHAT_THEME || env.CONSTRUCT_CHAT_THEME || '').trim().toLowerCase();
-  if (envTheme === 'light' || envTheme === 'dark') return envTheme;
-
-  const saved = String(configTheme || '').trim().toLowerCase();
-  if (saved === 'light' || saved === 'dark') return saved;
-
-  return detectTerminalColorScheme(env);
-}
-
-export function normalizeThemeSetting(value) {
-  const v = String(value || 'auto').trim().toLowerCase();
-  return THEME_VALUES.has(v) ? v : null;
-}

package/lib/chat/tui/markdown.mjs

@@ -1,123 +0,0 @@
-/**
- * lib/chat/tui/markdown.mjs — terminal-safe markdown subset for construct chat.
- *
- * Renders headings, lists, inline/fenced code, horizontal rules, and simple
- * pipe tables into plain lines suitable for Ink Text or linear stdout. Unknown
- * constructs pass through unchanged; the renderer never throws on bad input.
- */
-
-export function parseMarkdownLines(text, { width = 80 } = {}) {
-  if (!text) return [];
-  const lines = String(text).split('\n');
-  const out = [];
-  let inFence = false;
-  let fenceBuf = [];
-  let tableBuf = [];
-
-  const flushTable = () => {
-    if (!tableBuf.length) return;
-    out.push(...renderTable(tableBuf, width));
-    tableBuf = [];
-  };
-
-  for (const line of lines) {
-    if (/^```/.test(line.trim())) {
-      flushTable();
-      if (inFence) {
-        out.push(...fenceBuf.map((l) => ({ type: 'code', text: l })));
-        fenceBuf = [];
-        inFence = false;
-      } else {
-        inFence = true;
-      }
-      continue;
-    }
-    if (inFence) {
-      fenceBuf.push(line);
-      continue;
-    }
-
-    if (isTableRow(line)) {
-      tableBuf.push(line);
-      continue;
-    }
-    flushTable();
-
-    if (/^---+\s*$/.test(line.trim())) {
-      out.push({ type: 'rule' });
-      continue;
-    }
-
-    const heading = line.match(/^(#{1,3})\s+(.+)$/);
-    if (heading) {
-      out.push({ type: 'heading', level: heading[1].length, text: stripInline(heading[2]) });
-      continue;
-    }
-
-    const bullet = line.match(/^(\s*)[-*]\s+(.+)$/);
-    if (bullet) {
-      const indent = Math.floor(bullet[1].length / 2);
-      out.push({ type: 'bullet', indent, text: stripInline(bullet[2]) });
-      continue;
-    }
-
-    if (line.trim() === '') {
-      out.push({ type: 'blank' });
-      continue;
-    }
-
-    out.push({ type: 'paragraph', text: stripInline(line) });
-  }
-
-  flushTable();
-  if (inFence && fenceBuf.length) out.push(...fenceBuf.map((l) => ({ type: 'code', text: l })));
-  return out;
-}
-
-function isTableRow(line) {
-  const t = line.trim();
-  return t.includes('|') && !/^[\s|:-]+$/.test(t.replace(/\|/g, ''));
-}
-
-function renderTable(rows, width) {
-  const parsed = rows
-    .filter((r) => !/^\s*\|?[\s:-]+\|/.test(r))
-    .map((r) => r.split('|').map((c) => stripInline(c.trim())).filter((c, i, a) => !(i === 0 && c === '') && !(i === a.length - 1 && c === '')));
-  if (!parsed.length) return rows.map((r) => ({ type: 'paragraph', text: r }));
-
-  const cols = Math.max(...parsed.map((r) => r.length));
-  const colWidth = Math.max(8, Math.floor((width - cols - 1) / cols));
-  const out = [{ type: 'paragraph', text: '' }];
-  for (const row of parsed) {
-    const cells = row.map((c) => truncate(c, colWidth));
-    while (cells.length < cols) cells.push('');
-    out.push({ type: 'paragraph', text: cells.join(' | ') });
-  }
-  return out;
-}
-
-function truncate(s, max) {
-  if (s.length <= max) return s.padEnd(max);
-  return `${s.slice(0, max - 1)}…`;
-}
-
-function stripInline(s) {
-  return String(s)
-    .replace(/\*\*(.+?)\*\*/g, '$1')
-    .replace(/\*(.+?)\*/g, '$1')
-    .replace(/`([^`]+)`/g, '$1')
-    .replace(/\[(.+?)\]\([^)]+\)/g, '$1');
-}
-
-export function markdownToPlain(text, { width = 80 } = {}) {
-  return parseMarkdownLines(text, { width })
-    .map((part) => {
-      if (part.type === 'heading') return `${'#'.repeat(part.level)} ${part.text}`;
-      if (part.type === 'bullet') return `${'  '.repeat(part.indent)}- ${part.text}`;
-      if (part.type === 'code') return `  ${part.text}`;
-      if (part.type === 'rule') return '---';
-      if (part.type === 'blank') return '';
-      return part.text || '';
-    })
-    .join('\n');
-}

package/lib/chat/tui/presentation.mjs

@@ -1,100 +0,0 @@
-/**
- * lib/chat/tui/presentation.mjs — shared semantic presentation tokens for chat.
- *
- * Ink named colours and linear ANSI codes derive from one semantic map so the
- * rich and linear surfaces stay visually aligned across light and dark terminals.
- * Scheme resolution lives in color-scheme.mjs.
- */
-
-import { shouldUseColor } from '../../term-format.mjs';
-import { chatTerminalSemantic } from '../design-tokens.mjs';
-import { resolveTerminalColorScheme } from './color-scheme.mjs';
-
-const ESC = '\u001b[';
-
-const ASCII_GLYPHS = Object.freeze({
-  spinner: ['|', '/', '-', '\\'],
-  bullet: '*',
-  check: 'OK',
-  cross: 'X',
-  arrow: '->',
-  boxH: '-',
-  boxV: '|',
-});
-
-const UNICODE_GLYPHS = Object.freeze({
-  spinner: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'],
-  bullet: '•',
-  check: '✓',
-  cross: '✗',
-  arrow: '→',
-  boxH: '─',
-  boxV: '│',
-});
-
-const DARK_SEMANTIC = Object.freeze(chatTerminalSemantic('dark'));
-const LIGHT_SEMANTIC = Object.freeze(chatTerminalSemantic('light'));
-
-function semanticForScheme(scheme = 'dark') {
-  return scheme === 'light' ? LIGHT_SEMANTIC : DARK_SEMANTIC;
-}
-
-export function inkPalette({ scheme = 'dark' } = {}) {
-  const semantic = semanticForScheme(scheme);
-  return Object.fromEntries(Object.entries(semantic).map(([k, v]) => [k, v.ink]));
-}
-
-export function chatAnsiCodes({ scheme = 'dark' } = {}) {
-  const semantic = semanticForScheme(scheme);
-  return Object.fromEntries(Object.entries(semantic).map(([k, v]) => [k, v.code]));
-}
-
-export function resolveChatColors({
-  enabled = true,
-  stream = process.stdout,
-  env = process.env,
-  scheme: explicitScheme = null,
-  configTheme = null,
-} = {}) {
-  const scheme = explicitScheme || resolveTerminalColorScheme(env, configTheme);
-  const useColor = shouldUseColor({ enabled, stream, env });
-  const codes = chatAnsiCodes({ scheme });
-  const reset = useColor ? `${ESC}0m` : '';
-  const wrap = (code) => (useColor && code ? `${ESC}${code}m` : '');
-
-  const colors = {
-    scheme,
-    reset,
-    bold: wrap('1'),
-    dim: wrap('2'),
-    text: wrap(codes.text),
-    muted: wrap(codes.muted),
-    accent: wrap(codes.accent),
-    accentAlt: wrap(codes.accentAlt),
-    ok: wrap(codes.ok),
-    warn: wrap(codes.warn),
-    danger: wrap(codes.danger),
-    badgeFg: wrap(codes.badgeFg),
-    surface: wrap(codes.surface),
-    surfaceMuted: wrap(codes.surfaceMuted),
-    border: wrap(codes.border),
-    brandAccent: wrap(codes.brandAccent),
-    green: wrap(codes.ok),
-    yellow: wrap(codes.warn),
-    cyan: wrap(codes.accent),
-    red: wrap(codes.danger),
-  };
-
-  return colors;
-}
-
-export function createTheme({ scheme = 'dark', ascii = false, env = process.env, configTheme = null } = {}) {
-  const resolvedScheme = scheme || resolveTerminalColorScheme(env, configTheme);
-  return {
-    scheme: resolvedScheme,
-    palette: inkPalette({ scheme: resolvedScheme }),
-    glyphs: ascii ? ASCII_GLYPHS : UNICODE_GLYPHS,
-  };
-}
-
-export { DARK_SEMANTIC, LIGHT_SEMANTIC };