@laitszkin/apollo-toolkit 3.13.2 → 3.14.0

package/init-project-html/scripts/architecture.js

@@ -1,296 +0,0 @@
-#!/usr/bin/env node
-// architecture.js — thin shim over lib/atlas/cli.js.
-//
-// Backward-compatible legacy entrypoint:
-//   architecture.js                                # same as `open`
-//   architecture.js open  [--project <root>] [--no-open]
-//   architecture.js diff  [--project <root>] [--out <dir>] [--no-open]
-//
-// All new declarative verbs (feature add, submodule add, function add,
-// variable add, dataflow add|remove|reorder, error add, edge add, meta
-// set, actor add, render, validate, undo) are routed through
-// lib/atlas/cli.js, which owns layout, no-overlap, DOM, CSS, and pan/zoom.
-
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-const { spawn, spawnSync } = require('node:child_process');
-
-const newCli = require('../lib/atlas/cli');
-
-const ATLAS_REL = path.join('resources', 'project-architecture', 'index.html');
-const RESOURCES_REL = path.join('resources', 'project-architecture');
-const PLANS_REL = path.join('docs', 'plans');
-const DIFF_DIRNAME = 'architecture_diff';
-const REMOVED_FILE = '_removed.txt';
-const ATLAS_DIRNAME = 'atlas';
-const DEFAULT_OUT_REL = path.join('.apollo-toolkit', 'architecture-diff');
-
-const LEGACY_VERBS = new Set(['open', 'diff']);
-
-const USAGE = newCli.buildArchitectureHelpPage();
-
-function parseArgs(argv) {
-  const args = [...argv];
-  const result = {
-    subcommand: 'open',
-    projectRoot: null,
-    out: null,
-    open: true,
-    help: false,
-  };
-
-  if (args.length > 0 && !args[0].startsWith('-')) {
-    const candidate = args[0];
-    if (candidate === 'open' || candidate === 'diff') {
-      result.subcommand = candidate;
-      args.shift();
-    }
-  }
-
-  while (args.length > 0) {
-    const arg = args.shift();
-    if (arg === '--help' || arg === '-h') {
-      result.help = true;
-    } else if (arg === '--project') {
-      const value = args.shift();
-      if (!value) throw new Error('Missing value for --project');
-      result.projectRoot = path.resolve(value);
-    } else if (arg === '--out') {
-      const value = args.shift();
-      if (!value) throw new Error('Missing value for --out');
-      result.out = path.resolve(value);
-    } else if (arg === '--no-open') {
-      result.open = false;
-    } else {
-      throw new Error(`Unexpected argument: ${arg}`);
-    }
-  }
-
-  return result;
-}
-
-function findProjectRoot(startDir) {
-  let dir = path.resolve(startDir);
-  while (true) {
-    if (fs.existsSync(path.join(dir, ATLAS_REL))) return dir;
-    if (fs.existsSync(path.join(dir, RESOURCES_REL, ATLAS_DIRNAME, 'atlas.index.yaml'))) return dir;
-    const parent = path.dirname(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
-}
-
-function openInBrowser(filePath) {
-  const platform = process.platform;
-  let command;
-  let args;
-  if (platform === 'darwin') { command = 'open'; args = [filePath]; }
-  else if (platform === 'win32') { command = 'cmd'; args = ['/c', 'start', '""', filePath]; }
-  else { command = 'xdg-open'; args = [filePath]; }
-  try {
-    const child = spawn(command, args, { stdio: 'ignore', detached: true });
-    child.on('error', () => {});
-    child.unref();
-  } catch (_e) { /* best effort */ }
-}
-
-function walkArchitectureDiffDirs(plansRoot) {
-  const result = [];
-  if (!fs.existsSync(plansRoot)) return result;
-  function recurse(dir) {
-    let entries;
-    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch (_e) { return; }
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      if (entry.name === 'node_modules' || entry.name.startsWith('.')) continue;
-      const full = path.join(dir, entry.name);
-      if (entry.name === DIFF_DIRNAME) { result.push(full); continue; }
-      recurse(full);
-    }
-  }
-  recurse(plansRoot);
-  return result;
-}
-
-function walkAfterStateHtml(diffDir) {
-  const out = [];
-  function recurse(dir, relParts) {
-    let entries;
-    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch (_e) { return; }
-    for (const entry of entries) {
-      if (entry.name === 'assets') continue;
-      if (entry.name === ATLAS_DIRNAME) continue;
-      if (entry.name === REMOVED_FILE) continue;
-      if (entry.name.startsWith('.')) continue;
-      const full = path.join(dir, entry.name);
-      const nextRel = [...relParts, entry.name];
-      if (entry.isDirectory()) recurse(full, nextRel);
-      else if (entry.isFile() && entry.name.toLowerCase().endsWith('.html')) {
-        out.push({ abs: full, rel: nextRel.join('/') });
-      }
-    }
-  }
-  recurse(diffDir, []);
-  return out;
-}
-
-function readRemovedManifest(diffDir) {
-  const manifestPath = path.join(diffDir, REMOVED_FILE);
-  if (!fs.existsSync(manifestPath)) return [];
-  return fs.readFileSync(manifestPath, 'utf8')
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter((line) => line && !line.startsWith('#'));
-}
-
-function collectChanges(projectRoot) {
-  const resourcesRoot = path.join(projectRoot, RESOURCES_REL);
-  const plansRoot = path.join(projectRoot, PLANS_REL);
-  const diffDirs = walkArchitectureDiffDirs(plansRoot);
-  const changes = [];
-
-  for (const diffDir of diffDirs) {
-    const specDir = path.dirname(diffDir);
-    const specLabel = path.relative(projectRoot, specDir);
-    for (const after of walkAfterStateHtml(diffDir)) {
-      const beforeAbs = path.join(resourcesRoot, after.rel);
-      const beforeExists = fs.existsSync(beforeAbs);
-      changes.push({
-        kind: beforeExists ? 'modified' : 'added',
-        rel: after.rel,
-        spec: specLabel,
-        beforePath: beforeExists ? path.relative(projectRoot, beforeAbs) : null,
-        afterPath: path.relative(projectRoot, after.abs),
-      });
-    }
-    for (const removedRel of readRemovedManifest(diffDir)) {
-      const beforeAbs = path.join(resourcesRoot, removedRel);
-      if (!fs.existsSync(beforeAbs)) continue;
-      changes.push({
-        kind: 'removed',
-        rel: removedRel,
-        spec: specLabel,
-        beforePath: path.relative(projectRoot, beforeAbs),
-        afterPath: null,
-      });
-    }
-  }
-
-  changes.sort((a, b) => {
-    if (a.spec !== b.spec) return a.spec.localeCompare(b.spec);
-    if (a.kind !== b.kind) return a.kind.localeCompare(b.kind);
-    return a.rel.localeCompare(b.rel);
-  });
-  return changes;
-}
-
-function toViewerRel(outDir, projectRoot, projectRelPath) {
-  if (!projectRelPath) return null;
-  const absolute = path.resolve(projectRoot, projectRelPath);
-  const rel = path.relative(outDir, absolute);
-  return rel.split(path.sep).join('/');
-}
-
-function renderViewer({ changes, projectRoot, outDir }) {
-  return newCli.renderDiffViewer({ changes, projectRoot, outDir });
-}
-
-function runOpen(opts, io) {
-  let projectRoot = opts.projectRoot
-    ? path.resolve(opts.projectRoot)
-    : findProjectRoot(process.cwd());
-  if (!projectRoot) {
-    projectRoot = process.cwd();
-  }
-  fs.mkdirSync(path.join(projectRoot, RESOURCES_REL), { recursive: true });
-  const atlas = path.join(projectRoot, ATLAS_REL);
-  if (!fs.existsSync(atlas)) {
-    const bootstrap = path.join(__dirname, 'architecture-bootstrap-render.js');
-    const result = spawnSync(process.execPath, [bootstrap, 'render', '--project', projectRoot, '--no-open'], {
-      stdio: 'ignore',
-    });
-    if (result.status !== 0) {
-      io.stderr.write(`Atlas not found and render failed: ${atlas}\n`);
-      return 1;
-    }
-  }
-  if (!fs.existsSync(atlas)) {
-    io.stderr.write(`Atlas not found: ${atlas}\n`);
-    return 1;
-  }
-  io.stdout.write(`${atlas}\n`);
-  if (opts.open) openInBrowser(atlas);
-  return 0;
-}
-
-function runDiff(opts, io) {
-  let projectRoot = opts.projectRoot
-    ? path.resolve(opts.projectRoot)
-    : findProjectRoot(process.cwd());
-  if (!projectRoot) {
-    projectRoot = process.cwd();
-  }
-  const bootstrap = path.join(__dirname, 'architecture-bootstrap-render.js');
-  const args = [bootstrap, 'diff', '--project', projectRoot];
-  if (opts.out) args.push('--out', opts.out);
-  if (!opts.open) args.push('--no-open');
-  const result = spawnSync(process.execPath, args, { encoding: 'utf8' });
-  if (result.stdout) io.stdout.write(result.stdout);
-  if (result.stderr) io.stderr.write(result.stderr);
-  return result.status || 0;
-}
-
-// main(argv, io) is sync and supports the legacy verbs `open` and
-// `diff` only. Tests rely on the sync return-code contract. All other
-// verbs go through dispatchAsync().
-function main(argv, io = { stdout: process.stdout, stderr: process.stderr }) {
-  let opts;
-  try {
-    opts = parseArgs(argv);
-  } catch (error) {
-    io.stderr.write(`${error.message}\n\n${USAGE}\n`);
-    return 1;
-  }
-  if (opts.help) {
-    const explicitLegacyVerb = argv.length > 0 && !argv[0].startsWith('-') && LEGACY_VERBS.has(argv[0]);
-    const helpText = explicitLegacyVerb ? newCli.buildArchitectureHelpPage(argv[0]) : USAGE;
-    io.stdout.write(`${helpText}\n`);
-    return 0;
-  }
-  if (opts.subcommand === 'open') return runOpen(opts, io);
-  if (opts.subcommand === 'diff') return runDiff(opts, io);
-  io.stderr.write(`Unknown subcommand: ${opts.subcommand}\n\n${USAGE}\n`);
-  return 1;
-}
-
-async function dispatchAsync(argv, io = { stdout: process.stdout, stderr: process.stderr }) {
-  return newCli.dispatch(argv, io);
-}
-
-if (require.main === module) {
-  const argv = process.argv.slice(2);
-  const verb = argv[0];
-  if (!verb || verb.startsWith('-') || LEGACY_VERBS.has(verb)) {
-    process.exit(main(argv));
-  } else {
-    dispatchAsync(argv).then((code) => process.exit(code)).catch((err) => {
-      process.stderr.write(`${err && err.stack ? err.stack : err}\n`);
-      process.exit(1);
-    });
-  }
-}
-
-module.exports = {
-  parseArgs,
-  findProjectRoot,
-  collectChanges,
-  renderViewer,
-  toViewerRel,
-  walkArchitectureDiffDirs,
-  walkAfterStateHtml,
-  readRemovedManifest,
-  main,
-  dispatchAsync,
-};

package/katex/scripts/render_katex.py

@@ -1,247 +0,0 @@
-#!/usr/bin/env python3
-"""Render TeX formulas with the official KaTeX CLI and wrap the output for reuse."""
-
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import pathlib
-import subprocess
-import sys
-import tempfile
-from typing import Iterable
-
-
-DEFAULT_CSS_HREF = "https://cdn.jsdelivr.net/npm/katex@0.16.25/dist/katex.min.css"
-
-
-class KatexRenderError(Exception):
-    """User-facing error for rendering failures."""
-
-
-def parse_args(argv: list[str]) -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        prog="render_katex.py",
-        description="Render TeX with KaTeX and emit insertion-ready output.",
-    )
-
-    input_group = parser.add_mutually_exclusive_group(required=True)
-    input_group.add_argument("--tex", help="Raw TeX expression without delimiters.")
-    input_group.add_argument("--input-file", help="Path to a UTF-8 text file containing raw TeX.")
-
-    parser.add_argument(
-        "--output-format",
-        choices=("html-fragment", "html-page", "markdown-inline", "markdown-block", "json"),
-        default="html-fragment",
-        help="How to wrap the rendered KaTeX output.",
-    )
-    parser.add_argument(
-        "--katex-format",
-        choices=("html", "mathml", "htmlAndMathml"),
-        default="htmlAndMathml",
-        help="KaTeX internal output format.",
-    )
-    parser.add_argument("--display-mode", action="store_true", help="Render in display mode.")
-    parser.add_argument("--output-file", help="Write the wrapped output to a file.")
-    parser.add_argument("--css-href", default=DEFAULT_CSS_HREF, help="Stylesheet href for html-page/json output.")
-    parser.add_argument("--title", default="KaTeX Render", help="Document title for html-page output.")
-    parser.add_argument("--lang", default="en", help="HTML lang attribute for html-page output.")
-
-    parser.add_argument("--macro", action="append", default=[], help="Macro definition in NAME:VALUE form.")
-    parser.add_argument("--macro-file", help="Path to a JSON file mapping macro names to expansion strings.")
-    parser.add_argument("--error-color", help="Hex color or CSS color name for parse errors.")
-    parser.add_argument("--strict", help="KaTeX strict mode setting.")
-    parser.add_argument("--trust", help="KaTeX trust mode setting.")
-    parser.add_argument("--max-size", type=float, help="Maximum user-specified size in em.")
-    parser.add_argument("--max-expand", type=int, help="Maximum macro expansion count.")
-    parser.add_argument("--min-rule-thickness", type=float, help="Minimum rule thickness in em.")
-    parser.add_argument("--leqno", action="store_true", help="Render display equations with left equation numbers.")
-    parser.add_argument("--fleqn", action="store_true", help="Render display equations flush left.")
-    parser.add_argument(
-        "--color-is-text-color",
-        action="store_true",
-        help="Interpret \\\\color like legacy text color behavior.",
-    )
-    parser.add_argument(
-        "--no-throw-on-error",
-        action="store_true",
-        help="Render invalid input with colored source text instead of failing.",
-    )
-
-    return parser.parse_args(argv)
-
-
-def normalize_path(raw_path: str) -> pathlib.Path:
-    path = pathlib.Path(raw_path).expanduser()
-    if not path.is_absolute():
-        path = pathlib.Path.cwd() / path
-    return path.resolve()
-
-
-def load_tex(args: argparse.Namespace) -> str:
-    if args.input_file:
-        path = normalize_path(args.input_file)
-        if not path.is_file():
-            raise KatexRenderError(f"Input file not found: {path}")
-        return path.read_text(encoding="utf-8").strip()
-    return (args.tex or "").strip()
-
-
-def load_macro_pairs(values: Iterable[str]) -> list[tuple[str, str]]:
-    pairs: list[tuple[str, str]] = []
-    for raw_value in values:
-        if ":" not in raw_value:
-            raise KatexRenderError(f"Invalid --macro value '{raw_value}'. Use NAME:VALUE.")
-        name, expansion = raw_value.split(":", 1)
-        name = name.strip()
-        expansion = expansion.strip()
-        if not name or not expansion:
-            raise KatexRenderError(f"Invalid --macro value '{raw_value}'. Use NAME:VALUE.")
-        pairs.append((name, expansion))
-    return pairs
-
-
-def run_katex_cli(tex: str, args: argparse.Namespace) -> str:
-    command = [
-        "npx",
-        "--yes",
-        "--package",
-        "katex",
-        "katex",
-        "--format",
-        args.katex_format,
-    ]
-
-    if args.display_mode:
-        command.append("--display-mode")
-    if args.leqno:
-        command.append("--leqno")
-    if args.fleqn:
-        command.append("--fleqn")
-    if args.color_is_text_color:
-        command.append("--color-is-text-color")
-    if args.no_throw_on_error:
-        command.append("--no-throw-on-error")
-
-    if args.error_color:
-        command.extend(["--error-color", args.error_color])
-    if args.strict:
-        command.extend(["--strict", args.strict])
-    if args.trust:
-        command.extend(["--trust", args.trust])
-    if args.max_size is not None:
-        command.extend(["--max-size", str(args.max_size)])
-    if args.max_expand is not None:
-        command.extend(["--max-expand", str(args.max_expand)])
-    if args.min_rule_thickness is not None:
-        command.extend(["--min-rule-thickness", str(args.min_rule_thickness)])
-
-    for name, expansion in load_macro_pairs(args.macro):
-        command.extend(["--macro", f"{name}:{expansion}"])
-
-    if args.macro_file:
-        macro_file = normalize_path(args.macro_file)
-        if not macro_file.is_file():
-            raise KatexRenderError(f"Macro file not found: {macro_file}")
-        command.extend(["--macro-file", str(macro_file)])
-
-    with tempfile.NamedTemporaryFile("w", suffix=".tex", encoding="utf-8", delete=False) as handle:
-        handle.write(tex)
-        handle.write("\n")
-        temp_path = pathlib.Path(handle.name)
-
-    try:
-        command.extend(["--input", str(temp_path)])
-        result = subprocess.run(
-            command,
-            check=False,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-    finally:
-        temp_path.unlink(missing_ok=True)
-
-    if result.returncode != 0:
-        stderr = result.stderr.strip() or "KaTeX CLI failed."
-        raise KatexRenderError(stderr)
-
-    return result.stdout.strip()
-
-
-def build_html_page(rendered_html: str, args: argparse.Namespace) -> str:
-    css_link = ""
-    if args.css_href.strip():
-        css_link = f'  <link rel="stylesheet" href="{args.css_href.strip()}">\n'
-
-    return (
-        "<!DOCTYPE html>\n"
-        f'<html lang="{args.lang}">\n'
-        "<head>\n"
-        '  <meta charset="utf-8">\n'
-        f"  <title>{args.title}</title>\n"
-        f"{css_link}"
-        "</head>\n"
-        "<body>\n"
-        f"{rendered_html}\n"
-        "</body>\n"
-        "</html>\n"
-    )
-
-
-def wrap_output(rendered_html: str, tex: str, args: argparse.Namespace) -> str:
-    if args.output_format == "html-fragment":
-        return f"{rendered_html}\n"
-    if args.output_format == "html-page":
-        return build_html_page(rendered_html, args)
-    if args.output_format == "markdown-inline":
-        return f"{rendered_html}\n"
-    if args.output_format == "markdown-block":
-        return f"\n{rendered_html}\n"
-    if args.output_format == "json":
-        payload = {
-            "tex": tex,
-            "displayMode": args.display_mode,
-            "katexFormat": args.katex_format,
-            "cssHref": args.css_href,
-            "content": rendered_html,
-        }
-        return json.dumps(payload, ensure_ascii=False, indent=2) + "\n"
-    raise KatexRenderError(f"Unsupported output format: {args.output_format}")
-
-
-def write_output(content: str, output_file: str | None) -> None:
-    if not output_file:
-        sys.stdout.write(content)
-        return
-
-    path = normalize_path(output_file)
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(content, encoding="utf-8")
-    sys.stdout.write(str(path) + "\n")
-
-
-def main(argv: list[str]) -> int:
-    try:
-        args = parse_args(argv)
-        tex = load_tex(args)
-        if not tex:
-            raise KatexRenderError("Input TeX is empty.")
-        rendered_html = run_katex_cli(tex, args)
-        wrapped = wrap_output(rendered_html, tex, args)
-        write_output(wrapped, args.output_file)
-        return 0
-    except KatexRenderError as exc:
-        print(f"[ERROR] {exc}", file=sys.stderr)
-        return 1
-    except FileNotFoundError as exc:
-        missing = exc.filename or "required executable"
-        if os.path.basename(missing) in {"npx", "node"}:
-            print("[ERROR] node and npx are required to render KaTeX.", file=sys.stderr)
-            return 1
-        raise
-
-
-if __name__ == "__main__":
-    raise SystemExit(main(sys.argv[1:]))

package/katex/scripts/render_katex.sh

@@ -1,11 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
-
-if ! command -v python3 >/dev/null 2>&1; then
-  echo "[ERROR] python3 is required." >&2
-  exit 1
-fi
-
-exec python3 "$script_dir/render_katex.py" "$@"