archymedes-cli 2.1.0 → 2.3.0

package/dist/{archymedes-2tp22t9a.mjs → archymedes-twbks7g3.mjs}

@@ -1,13 +1,15 @@
 import {
-  ASCII_GLYPHS,
-  UNICODE_GLYPHS,
   padToWidth,
   progressBar,
-  sliceToWidth,
+  sliceToWidth
+} from "./archymedes-g8y3rt6t.mjs";
+import {
+  ASCII_GLYPHS,
+  UNICODE_GLYPHS,
   visibleWidth
-} from "./archymedes-dwvn4c51.mjs";
+} from "./archymedes-a10k8yrk.mjs";
 
-// packages/archymedes-cli/src/canvas.ts
+// src/render/canvas.ts
 var BRAILLE_DOTS = [
   [1, 2, 4, 64],
   [8, 16, 32, 128]
@@ -93,7 +95,7 @@ function seriesBounds(values) {
   return { low, high, span: high - low === 0 ? 1 : high - low };
 }
 
-// packages/archymedes-cli/src/charts.ts
+// src/render/charts.ts
 function barChart(data, options) {
   if (data.length === 0)
     return [];
@@ -251,4 +253,4 @@ function heatStrip(data, options) {
   });
 }
 
-export { BrailleCanvas, dotRowFor, seriesBounds, barChart, lineChart, plotSeries, scatterChart, waveLine, StreamSeries, heatStrip };
+export { barChart, lineChart, plotSeries, scatterChart, waveLine, StreamSeries, heatStrip };

package/dist/{editor-screen-51z7z11j.mjs → editor-screen-g08zzt70.mjs}

@@ -1,15 +1,20 @@
+import {
+  diffLines,
+  languageOf
+} from "./archymedes-dz59nvw7.mjs";
+import"./archymedes-tsne2m7p.mjs";
 import {
   NO_COLOR_PALETTE
-} from "./archymedes-jecyxv5c.mjs";
+} from "./archymedes-a10k8yrk.mjs";
 import {
   __require
 } from "./archymedes-x67v3n58.mjs";
 
-// packages/archymedes-cli/src/editor-screen.tsx
+// src/ui/editor-screen.tsx
 import { useInput, useState } from "@termuijs/jsx";
 import { Box, Text } from "@termuijs/widgets";
 
-// packages/archymedes-cli/src/editor.ts
+// src/ui/editor.ts
 function initialEditorState(path, content, viewportRows = 20) {
   const lines = content.split(`
 `);
@@ -342,14 +347,234 @@ function caretInto(text, cursorCol) {
   return `${padded.slice(0, cursorCol)}█${padded.slice(cursorCol + 1)}`;
 }
 
-// packages/archymedes-cli/src/editor-screen.tsx
+// src/ui/explain-view.ts
+var PATTERNS = {
+  typescript: {
+    imports: /^\s*import\b.*from\s+["'](.+)["']/,
+    exports: /^\s*export\s+(?:default\s+)?(?:const|function|class|interface|type|enum)\s+([\w$]+)/,
+    functions: /^\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s*\*?\s*([\w$]+)/,
+    classes: /^\s*(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+([\w$]+)/
+  },
+  javascript: {},
+  jsx: {},
+  tsx: {},
+  python: {
+    imports: /^\s*(?:import\s+([\w.]+)|from\s+([\w.]+)\s+import\b)/,
+    functions: /^\s*(?:async\s+)?def\s+([\w]+)/,
+    classes: /^\s*class\s+([\w]+)/
+  },
+  go: {
+    imports: /^\s*import\s+["'](.+)["']/,
+    functions: /^\s*func\s+(?:\([^)]*\)\s*)?([\w]+)/
+  },
+  rust: {
+    imports: /^\s*use\s+([\w:]+)/,
+    functions: /^\s*(?:pub\s+)?(?:async\s+)?fn\s+([\w]+)/,
+    classes: /^\s*(?:pub\s+)?struct\s+([\w]+)/
+  },
+  ruby: {
+    imports: /^\s*require\s+["'](.+)["']/,
+    functions: /^\s*def\s+([\w?!]+)/,
+    classes: /^\s*class\s+([\w:]+)/
+  }
+};
+PATTERNS.javascript = PATTERNS.typescript;
+PATTERNS.jsx = PATTERNS.typescript;
+PATTERNS.tsx = PATTERNS.typescript;
+function structuralFacts(content, path) {
+  const language = languageOf(path);
+  const rules = PATTERNS[language] ?? {};
+  const facts = { imports: [], exports: [], functions: [], classes: [] };
+  const lines = content.split(`
+`);
+  lines.forEach((raw, index) => {
+    for (const key of Object.keys(rules)) {
+      const pattern = rules[key];
+      if (!pattern)
+        continue;
+      const match = pattern.exec(raw);
+      if (!match)
+        continue;
+      const name = match.slice(1).find((group) => group !== undefined);
+      facts[key].push({ line: index + 1, text: name ?? raw.trim() });
+    }
+  });
+  return facts;
+}
+var MAX_LINE_LENGTH = 120;
+var MAGIC_NUMBER = /(?<![\w.])(?!0\b|1\b)\d{2,}(?![\w.])/;
+function annotateLines(content) {
+  const lines = content.split(`
+`);
+  const notes = [];
+  lines.forEach((raw, index) => {
+    const line = index + 1;
+    if (/\b(TODO|FIXME|HACK|XXX)\b/.test(raw)) {
+      notes.push({ line, note: "unfinished work flagged here", severity: "warn" });
+    }
+    if (raw.length > MAX_LINE_LENGTH) {
+      notes.push({ line, note: `long line (${raw.length} chars)`, severity: "info" });
+    }
+    if (MAGIC_NUMBER.test(raw) && !/^\s*(?:\/\/|#|\*)/.test(raw)) {
+      notes.push({ line, note: "unexplained numeric literal", severity: "info" });
+    }
+  });
+  return notes;
+}
+var EXPLAIN_TABS = ["facts", "notes", "diff", "ai"];
+function initialExplainPanelState() {
+  return { open: false, tab: "facts", ai: { status: "idle" } };
+}
+function toggleExplainPanel(state) {
+  return { ...state, open: !state.open };
+}
+function cycleExplainTab(state, step = 1) {
+  const index = EXPLAIN_TABS.indexOf(state.tab);
+  const next = ((index + step) % EXPLAIN_TABS.length + EXPLAIN_TABS.length) % EXPLAIN_TABS.length;
+  return { ...state, tab: EXPLAIN_TABS[next] };
+}
+function withAiExplanation(state, ai) {
+  return { ...state, ai };
+}
+var DEFAULT_EXPLAIN_COLORS = { success: "green", warning: "yellow", error: "red" };
+var TAB_LABELS = { facts: "Structure", notes: "Notes", diff: "Diff", ai: "AI" };
+function tabStrip(active) {
+  const text = EXPLAIN_TABS.map((tab) => tab === active ? `[${TAB_LABELS[tab]}]` : ` ${TAB_LABELS[tab]} `).join(" ");
+  return { text, bold: true };
+}
+function hintRow(active) {
+  const ask = active === "ai" ? "   ? ask" : "";
+  return { text: `[ ] tabs   ^E close${ask}`, dim: true };
+}
+function wrap(text, width) {
+  const words = text.split(/\s+/).filter(Boolean);
+  const rows = [];
+  let line = "";
+  for (const word of words) {
+    const candidate = line ? `${line} ${word}` : word;
+    if (candidate.length > width && line) {
+      rows.push(line);
+      line = word;
+    } else {
+      line = candidate;
+    }
+  }
+  if (line)
+    rows.push(line);
+  return rows.length > 0 ? rows : [""];
+}
+function factsRows(facts, width) {
+  const section = (title, entries) => {
+    if (entries.length === 0)
+      return [];
+    return [
+      { text: title, bold: true },
+      ...entries.slice(0, 40).map((entry) => ({ text: `  ${String(entry.line).padStart(4)}  ${entry.text}`.slice(0, width) })),
+      { text: "" }
+    ];
+  };
+  const rows = [
+    ...section("Imports", facts.imports),
+    ...section("Exports", facts.exports),
+    ...section("Classes", facts.classes),
+    ...section("Functions", facts.functions)
+  ];
+  if (rows.length === 0)
+    return [{ text: "No imports, exports, functions or classes recognised.", dim: true }];
+  return rows.slice(0, -1);
+}
+function notesRows(notes, width, colors) {
+  if (notes.length === 0)
+    return [{ text: "Nothing flagged.", dim: true }];
+  return notes.slice(0, 60).map((entry) => ({
+    text: `${String(entry.line).padStart(4)}  ${entry.note}`.slice(0, width),
+    color: entry.severity === "warn" ? colors.warning : undefined
+  }));
+}
+function diffRows(diff, width, colors) {
+  if (diff.length === 0 || diff.every((line) => line.kind === "context")) {
+    return [{ text: "No changes yet.", dim: true }];
+  }
+  return diff.filter((line) => line.kind !== "context").slice(0, 200).map((line) => ({
+    text: `${line.kind === "add" ? "+" : "-"} ${line.text}`.slice(0, width),
+    color: line.kind === "add" ? colors.success : colors.error
+  }));
+}
+function aiRows(ai, width, colors) {
+  switch (ai.status) {
+    case "idle":
+      return [{ text: "Press ? to ask the model to explain this file.", dim: true }];
+    case "loading":
+      return [{ text: "Thinking…", dim: true }];
+    case "error":
+      return [{ text: `Could not get an explanation: ${ai.message}`, color: colors.error }];
+    case "ready":
+      return ai.text.split(`
+`).flatMap((line) => wrap(line, width)).map((text) => ({ text }));
+  }
+}
+function composeExplainPanel(input, width, height, colors = DEFAULT_EXPLAIN_COLORS) {
+  const body = (() => {
+    switch (input.panel.tab) {
+      case "facts":
+        return factsRows(structuralFacts(input.after, input.path), width);
+      case "notes":
+        return notesRows(annotateLines(input.after), width, colors);
+      case "diff":
+        return diffRows(diffLines(input.before, input.after), width, colors);
+      case "ai":
+        return aiRows(input.panel.ai, width, colors);
+    }
+  })();
+  const rows = [tabStrip(input.panel.tab), hintRow(input.panel.tab), { text: "" }, ...body];
+  const padded = rows.length >= height ? rows.slice(0, height) : [...rows, ...Array.from({ length: height - rows.length }, () => ({ text: "" }))];
+  return padded;
+}
+
+// src/ui/editor-screen.tsx
 import { jsxDEV } from "@termuijs/jsx/jsx-dev-runtime";
 var Panel = Box;
 var Line = Text;
 var CHROME_ROWS = 2;
-function EditorScreen({ columns, rows, path, content, onExit, palette = NO_COLOR_PALETTE }) {
+var MIN_CODE_COLUMNS = 30;
+var MAX_PANEL_COLUMNS = 52;
+function panelWidthFor(columns) {
+  if (columns - MIN_CODE_COLUMNS < 20)
+    return 0;
+  return Math.min(MAX_PANEL_COLUMNS, Math.floor(columns * 0.38), columns - MIN_CODE_COLUMNS);
+}
+function EditorScreen({ columns, rows, path, content, onExit, palette = NO_COLOR_PALETTE, explain }) {
   const [state, setState] = useState(() => initialEditorState(path, content, Math.max(1, rows - CHROME_ROWS)));
+  const [panel, setPanel] = useState(() => initialExplainPanelState());
+  const panelWidth = panel.open ? panelWidthFor(columns) : 0;
+  const codeWidth = panelWidth > 0 ? columns - panelWidth - 1 : columns;
+  const askAi = (currentContent) => {
+    if (!explain) {
+      setPanel((current) => withAiExplanation(current, { status: "error", message: "no model available in this session" }));
+      return;
+    }
+    setPanel((current) => withAiExplanation(current, { status: "loading" }));
+    explain(currentContent, path).then((text) => setPanel((current) => withAiExplanation(current, { status: "ready", text })), (error) => setPanel((current) => withAiExplanation(current, { status: "error", message: error instanceof Error ? error.message : String(error) })));
+  };
   useInput((input, key) => {
+    if (key?.ctrl && key?.key === "e") {
+      setPanel((current) => toggleExplainPanel(current));
+      return;
+    }
+    if (panel.open && state.mode === "normal" && !state.search.typing) {
+      if (input === "]") {
+        setPanel((current) => cycleExplainTab(current, 1));
+        return;
+      }
+      if (input === "[") {
+        setPanel((current) => cycleExplainTab(current, -1));
+        return;
+      }
+      if (input === "?" && panel.tab === "ai" && panel.ai.status !== "loading") {
+        askAi(editorContent(state));
+        return;
+      }
+    }
     setState((current) => {
       const action = keyToEditorAction({ name: key?.key, ctrl: key?.ctrl, shift: key?.shift }, input, current);
       const { state: next, effect } = applyEditorAction(current, action);
@@ -360,18 +585,41 @@ function EditorScreen({ columns, rows, path, content, onExit, palette = NO_COLOR
       return next;
     });
   });
-  const frame = composeEditorFrame(state, columns, palette.accent);
+  const frame = composeEditorFrame(state, codeWidth, palette.tokens.accent);
+  const lastRow = frame.length - 1;
+  if (!panel.open && lastRow >= 0 && frame[lastRow].text.length + "   ^E explain".length <= codeWidth) {
+    frame[lastRow] = { ...frame[lastRow], text: `${frame[lastRow].text}   ^E explain` };
+  }
+  const panelRows = panelWidth > 0 ? composeExplainPanel({ path, before: content, after: editorContent(state), panel }, panelWidth - 2, rows, palette.tokens) : [];
   return /* @__PURE__ */ jsxDEV(Panel, {
-    flexDirection: "column",
+    flexDirection: "row",
     width: columns,
     height: rows,
-    children: frame.map((line, index) => /* @__PURE__ */ jsxDEV(Line, {
-      bold: line.bold,
-      dimColor: line.dim,
-      color: line.color,
-      children: line.text
-    }, `row-${index}`, false, undefined, this))
-  }, undefined, false, undefined, this);
+    children: [
+      /* @__PURE__ */ jsxDEV(Panel, {
+        flexDirection: "column",
+        width: codeWidth,
+        height: rows,
+        children: frame.map((line, index) => /* @__PURE__ */ jsxDEV(Line, {
+          bold: line.bold,
+          dimColor: line.dim,
+          color: line.color,
+          children: line.text
+        }, `row-${index}`, false, undefined, this))
+      }, undefined, false, undefined, this),
+      panelWidth > 0 && /* @__PURE__ */ jsxDEV(Panel, {
+        flexDirection: "column",
+        width: panelWidth,
+        height: rows,
+        children: panelRows.map((line, index) => /* @__PURE__ */ jsxDEV(Line, {
+          bold: line.bold,
+          dimColor: line.dim,
+          color: line.color,
+          children: line.text
+        }, `explain-${index}`, false, undefined, this))
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
 }
 async function runEditorScreen(options) {
   const { renderApp } = await import("@termuijs/jsx");
@@ -389,6 +637,7 @@ async function runEditorScreen(options) {
       path: options.path,
       content: options.content,
       palette: options.palette,
+      explain: options.explain,
       onExit: finish,
       fullscreen: true
     }).catch(() => finish(undefined));