@laitszkin/apollo-toolkit 2.0.0

package/learning-error-book/scripts/render_markdown_to_pdf.py

@@ -0,0 +1,367 @@
+#!/usr/bin/env python3
+"""
+Render a small Markdown subset to PDF using ReportLab.
+
+Why not use pandoc/markdown/weasyprint?
+- This repo environment may not have those installed.
+- ReportLab is already available and works offline.
+
+Supported Markdown subset:
+- Headings: # / ## / ###
+- Unordered lists: "- " or "* "
+- Ordered lists: "1. "
+- Fenced code blocks: ``` (optional language ignored)
+- Inline: **bold**, *italic*, `code`
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+from dataclasses import dataclass
+from typing import Iterable, List, Optional, Tuple
+
+from reportlab.lib.pagesizes import A4, letter
+from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet
+from reportlab.lib.units import mm
+from reportlab.pdfbase import pdfmetrics
+from reportlab.pdfbase.ttfonts import TTFont
+from reportlab.platypus import (
+    SimpleDocTemplate,
+    Spacer,
+    Paragraph,
+    Preformatted,
+    ListFlowable,
+    ListItem,
+)
+
+
+def _read_text(path: str) -> str:
+    with open(path, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+def _ensure_parent_dir(path: str) -> None:
+    parent = os.path.dirname(os.path.abspath(path))
+    if parent:
+        os.makedirs(parent, exist_ok=True)
+
+
+def _detect_cjk_font_path(user_font_path: Optional[str]) -> Tuple[str, int]:
+    """
+    Returns (font_path, subfont_index).
+
+    ReportLab can load TTC via subfontIndex. We default to 0.
+    """
+    if user_font_path:
+        return user_font_path, 0
+
+    candidates = [
+        # macOS common CJK fonts
+        "/System/Library/Fonts/PingFang.ttc",
+        "/System/Library/Fonts/STHeiti Light.ttc",
+        "/System/Library/Fonts/STHeiti Medium.ttc",
+        "/System/Library/Fonts/ヒラギノ角ゴシック W3.ttc",
+        "/System/Library/Fonts/ヒラギノ角ゴシック W4.ttc",
+        "/System/Library/Fonts/ヒラギノ角ゴシック W5.ttc",
+        "/System/Library/Fonts/ヒラギノ明朝 ProN.ttc",
+        # Some systems may have these
+        "/Library/Fonts/Arial Unicode.ttf",
+    ]
+    for p in candidates:
+        if os.path.exists(p):
+            return p, 0
+    raise SystemExit(
+        "No CJK font found. Re-run with --font-path pointing to a .ttf/.otf/.ttc font file."
+    )
+
+
+def _register_fonts(font_path: str, subfont_index: int) -> Tuple[str, str]:
+    """
+    Registers a CJK-capable font for body text. Returns (body_font_name, code_font_name).
+    """
+    body_font_name = "ErrorBookBodyFont"
+    # Avoid double registration errors when the script is invoked multiple times.
+    if body_font_name not in pdfmetrics.getRegisteredFontNames():
+        pdfmetrics.registerFont(TTFont(body_font_name, font_path, subfontIndex=subfont_index))
+
+    # Code blocks: built-in Courier is fine for ASCII code and Markdown symbols.
+    code_font_name = "Courier"
+    return body_font_name, code_font_name
+
+
+def _xml_escape(s: str) -> str:
+    return (
+        s.replace("&", "&")
+        .replace("<", "&lt;")
+        .replace(">", "&gt;")
+        .replace('"', "&quot;")
+    )
+
+
+_RE_BOLD = re.compile(r"\*\*(.+?)\*\*")
+_RE_ITALIC = re.compile(r"(?<!\*)\*(?!\s)(.+?)(?<!\s)\*(?!\*)")
+_RE_CODE = re.compile(r"`([^`]+?)`")
+
+
+def _inline_to_rl_markup(text: str, code_font: str) -> str:
+    """
+    Convert a subset of inline Markdown to ReportLab Paragraph markup.
+    """
+    text = _xml_escape(text)
+
+    # Inline code first to avoid formatting inside code spans.
+    def repl_code(m: re.Match) -> str:
+        # `text` has already been XML-escaped, so do not escape again here;
+        # otherwise sequences like "<" become "&amp;lt;" inside code spans.
+        return f'<font face="{code_font}">{m.group(1)}</font>'
+
+    text = _RE_CODE.sub(repl_code, text)
+    text = _RE_BOLD.sub(r"<b>\1</b>", text)
+    text = _RE_ITALIC.sub(r"<i>\1</i>", text)
+    return text
+
+
+@dataclass(frozen=True)
+class Block:
+    kind: str
+    lines: Tuple[str, ...]
+
+
+def _parse_blocks(md: str) -> List[Block]:
+    """
+    Parse Markdown into coarse blocks to keep rendering predictable.
+    """
+    lines = md.splitlines()
+    blocks: List[Block] = []
+
+    i = 0
+    in_code = False
+    code_buf: List[str] = []
+    para_buf: List[str] = []
+    list_buf: List[str] = []
+    list_kind: Optional[str] = None  # "ul" or "ol"
+
+    def flush_para() -> None:
+        nonlocal para_buf
+        if para_buf:
+            blocks.append(Block("para", tuple(para_buf)))
+            para_buf = []
+
+    def flush_list() -> None:
+        nonlocal list_buf, list_kind
+        if list_buf and list_kind:
+            blocks.append(Block(list_kind, tuple(list_buf)))
+        list_buf = []
+        list_kind = None
+
+    while i < len(lines):
+        line = lines[i]
+
+        if line.strip().startswith("```"):
+            if in_code:
+                # end code
+                blocks.append(Block("code", tuple(code_buf)))
+                code_buf = []
+                in_code = False
+            else:
+                # start code
+                flush_para()
+                flush_list()
+                in_code = True
+                code_buf = []
+            i += 1
+            continue
+
+        if in_code:
+            code_buf.append(line.rstrip("\n"))
+            i += 1
+            continue
+
+        # Blank line breaks paragraphs/lists
+        if not line.strip():
+            flush_para()
+            flush_list()
+            i += 1
+            continue
+
+        # Headings
+        if line.startswith("#"):
+            flush_para()
+            flush_list()
+            m = re.match(r"^(#{1,6})\s+(.*)$", line)
+            if m:
+                level = len(m.group(1))
+                blocks.append(Block(f"h{level}", (m.group(2).strip(),)))
+                i += 1
+                continue
+
+        # Lists (simple, non-nested)
+        m_ul = re.match(r"^\s*[-\*]\s+(.*)$", line)
+        m_ol = re.match(r"^\s*\d+\.\s+(.*)$", line)
+        if m_ul:
+            flush_para()
+            if list_kind not in (None, "ul"):
+                flush_list()
+            list_kind = "ul"
+            list_buf.append(m_ul.group(1))
+            i += 1
+            continue
+        if m_ol:
+            flush_para()
+            if list_kind not in (None, "ol"):
+                flush_list()
+            list_kind = "ol"
+            list_buf.append(m_ol.group(1))
+            i += 1
+            continue
+
+        # Default: paragraph line (we keep soft-wrapping by joining with spaces)
+        flush_list()
+        para_buf.append(line.strip())
+        i += 1
+
+    # EOF flush
+    if in_code:
+        blocks.append(Block("code", tuple(code_buf)))
+    flush_para()
+    flush_list()
+
+    return blocks
+
+
+def _build_story(
+    blocks: Iterable[Block],
+    body_font: str,
+    code_font: str,
+    base_font_size: int,
+) -> List[object]:
+    styles = getSampleStyleSheet()
+
+    normal = ParagraphStyle(
+        "ErrorBookNormal",
+        parent=styles["Normal"],
+        fontName=body_font,
+        fontSize=base_font_size,
+        leading=int(base_font_size * 1.45),
+        spaceAfter=6,
+    )
+    h1 = ParagraphStyle(
+        "ErrorBookH1",
+        parent=styles["Heading1"],
+        fontName=body_font,
+        fontSize=base_font_size + 8,
+        leading=int((base_font_size + 8) * 1.2),
+        spaceBefore=10,
+        spaceAfter=8,
+    )
+    h2 = ParagraphStyle(
+        "ErrorBookH2",
+        parent=styles["Heading2"],
+        fontName=body_font,
+        fontSize=base_font_size + 4,
+        leading=int((base_font_size + 4) * 1.2),
+        spaceBefore=10,
+        spaceAfter=6,
+    )
+    h3 = ParagraphStyle(
+        "ErrorBookH3",
+        parent=styles["Heading3"],
+        fontName=body_font,
+        fontSize=base_font_size + 2,
+        leading=int((base_font_size + 2) * 1.2),
+        spaceBefore=8,
+        spaceAfter=4,
+    )
+
+    story: List[object] = []
+    for b in blocks:
+        if b.kind == "para":
+            text = " ".join(b.lines)
+            story.append(Paragraph(_inline_to_rl_markup(text, code_font), normal))
+        elif b.kind in ("h1", "h2", "h3"):
+            text = b.lines[0] if b.lines else ""
+            style = {"h1": h1, "h2": h2, "h3": h3}[b.kind]
+            story.append(Paragraph(_inline_to_rl_markup(text, code_font), style))
+        elif b.kind.startswith("h"):
+            # Fallback: treat other heading levels as h3
+            text = b.lines[0] if b.lines else ""
+            story.append(Paragraph(_inline_to_rl_markup(text, code_font), h3))
+        elif b.kind == "code":
+            code_text = "\n".join(b.lines)
+            story.append(
+                Preformatted(
+                    code_text,
+                    ParagraphStyle(
+                        "ErrorBookCode",
+                        fontName=code_font,
+                        fontSize=max(9, base_font_size - 1),
+                        leading=int(max(9, base_font_size - 1) * 1.25),
+                        backColor=None,
+                    ),
+                )
+            )
+            story.append(Spacer(1, 4))
+        elif b.kind in ("ul", "ol"):
+            is_ordered = b.kind == "ol"
+            items: List[ListItem] = []
+            for item in b.lines:
+                items.append(ListItem(Paragraph(_inline_to_rl_markup(item, code_font), normal)))
+            story.append(
+                ListFlowable(
+                    items,
+                    bulletType="1" if is_ordered else "bullet",
+                    start="1",
+                    leftIndent=14,
+                    bulletFontName=body_font,
+                    bulletFontSize=base_font_size,
+                    bulletOffsetY=0,
+                )
+            )
+            story.append(Spacer(1, 6))
+        else:
+            # Unknown block type: render as plain text.
+            text = " ".join(b.lines)
+            story.append(Paragraph(_inline_to_rl_markup(text, code_font), normal))
+
+    return story
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Render Markdown to PDF (CJK-friendly) via ReportLab.")
+    parser.add_argument("input_md", help="Input Markdown file path")
+    parser.add_argument("output_pdf", help="Output PDF file path")
+    parser.add_argument("--font-path", default=None, help="Path to a CJK-capable font file (.ttf/.otf/.ttc)")
+    parser.add_argument("--font-size", type=int, default=12, help="Base font size (default: 12)")
+    parser.add_argument("--pagesize", choices=["a4", "letter"], default="a4", help="Page size (default: a4)")
+    parser.add_argument("--margin-mm", type=float, default=18.0, help="Page margin in mm (default: 18)")
+    args = parser.parse_args()
+
+    md = _read_text(args.input_md)
+    blocks = _parse_blocks(md)
+
+    font_path, subfont_index = _detect_cjk_font_path(args.font_path)
+    body_font, code_font = _register_fonts(font_path, subfont_index)
+
+    page_size = A4 if args.pagesize == "a4" else letter
+    margin = args.margin_mm * mm
+
+    _ensure_parent_dir(args.output_pdf)
+    doc = SimpleDocTemplate(
+        args.output_pdf,
+        pagesize=page_size,
+        leftMargin=margin,
+        rightMargin=margin,
+        topMargin=margin,
+        bottomMargin=margin,
+        title=os.path.basename(args.output_pdf),
+    )
+
+    story = _build_story(blocks, body_font, code_font, args.font_size)
+    doc.build(story)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/lib/cli.js

@@ -0,0 +1,338 @@
+const { createInterface } = require('node:readline/promises');
+const path = require('node:path');
+
+const {
+  VALID_MODES,
+  installLinks,
+  normalizeModes,
+  resolveToolkitHome,
+  syncToolkitHome,
+  getTargetRoots,
+} = require('./installer');
+
+const TARGET_OPTIONS = [
+  { id: 'all', label: 'All', description: 'Install every supported target below' },
+  { id: 'codex', label: 'Codex', description: '~/.codex/skills' },
+  { id: 'openclaw', label: 'OpenClaw', description: '~/.openclaw/workspace*/skills' },
+  { id: 'trae', label: 'Trae', description: '~/.trae/skills' },
+];
+
+function supportsColor(stream, env = process.env) {
+  return Boolean(stream && stream.isTTY && !env.NO_COLOR);
+}
+
+function color(text, code, enabled) {
+  if (!enabled) {
+    return text;
+  }
+
+  return `\u001b[${code}m${text}\u001b[0m`;
+}
+
+function buildBanner({ version, colorEnabled }) {
+  const lines = [
+    '+------------------------------------------+',
+    '|              Apollo Toolkit              |',
+    '|      npm installer and skill linker      |',
+    '+------------------------------------------+',
+    `Version ${version}`,
+  ];
+
+  return lines
+    .map((line, index) => {
+      if (index <= 2) {
+        return color(line, '1;36', colorEnabled);
+      }
+      return color(line, '2', colorEnabled);
+    })
+    .join('\n');
+}
+
+function buildHelpText({ version, colorEnabled }) {
+  return [
+    buildBanner({ version, colorEnabled }),
+    '',
+    'Usage:',
+    '  apollo-toolkit [install] [codex|openclaw|trae|all]...',
+    '  apollo-toolkit --help',
+    '',
+    'Examples:',
+    '  npx @laitszkin/apollo-toolkit',
+    '  npx @laitszkin/apollo-toolkit codex openclaw',
+    '  npm i -g @laitszkin/apollo-toolkit',
+    '  apollo-toolkit all',
+    '',
+    'Options:',
+    '  --home <path>  Override Apollo Toolkit home directory',
+    '  --help         Show this help text',
+  ].join('\n');
+}
+
+function parseArguments(argv) {
+  const args = [...argv];
+  const result = {
+    modes: [],
+    showHelp: false,
+    toolkitHome: null,
+  };
+
+  while (args.length > 0) {
+    const arg = args.shift();
+
+    if (arg === '--help' || arg === '-h') {
+      result.showHelp = true;
+      continue;
+    }
+
+    if (arg === '--home') {
+      const toolkitHome = args.shift();
+      if (!toolkitHome) {
+        throw new Error('Missing value for --home');
+      }
+      result.toolkitHome = path.resolve(toolkitHome);
+      continue;
+    }
+
+    if (arg === 'install') {
+      continue;
+    }
+
+    result.modes.push(arg);
+  }
+
+  return result;
+}
+
+function clearScreen(output) {
+  if (output.isTTY) {
+    output.write('\u001b[2J\u001b[H');
+  }
+}
+
+function renderSelectionScreen({ output, version, cursor, selected, message, env }) {
+  const colorEnabled = supportsColor(output, env);
+  const allSelected = VALID_MODES.every((mode) => selected.has(mode));
+
+  clearScreen(output);
+  output.write(`${buildBanner({ version, colorEnabled })}\n\n`);
+  output.write('Choose where Apollo Toolkit should create symlinked skills.\n');
+  output.write('Use Up/Down (or j/k) to move, Space to toggle, Enter to continue.\n');
+  output.write('Press a to toggle all, q to cancel.\n\n');
+
+  TARGET_OPTIONS.forEach((option, index) => {
+    const isFocused = index === cursor;
+    const isChecked = option.id === 'all' ? allSelected : selected.has(option.id);
+    const prefix = isFocused ? color('>', '1;33', colorEnabled) : ' ';
+    const checkbox = isChecked ? color('[x]', '1;32', colorEnabled) : '[ ]';
+    const label = isFocused ? color(option.label, '1', colorEnabled) : option.label;
+    output.write(`${prefix} ${checkbox} ${label}  ${color(option.description, '2', colorEnabled)}\n`);
+  });
+
+  const selectedModes = allSelected ? [...VALID_MODES] : [...selected].sort();
+  output.write('\n');
+  output.write(`Selected: ${selectedModes.length > 0 ? selectedModes.join(', ') : 'none'}\n`);
+  if (message) {
+    output.write(`${color(message, '1;31', colorEnabled)}\n`);
+  }
+}
+
+async function promptForModes({ stdin, stdout, version, env }) {
+  if (!stdin.isTTY || !stdout.isTTY) {
+    throw new Error('Interactive install requires a TTY. Re-run with targets like `codex`, `openclaw`, `trae`, or `all`.');
+  }
+
+  return new Promise((resolve, reject) => {
+    let cursor = 0;
+    let message = '';
+    const selected = new Set();
+
+    const cleanup = () => {
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdin.removeListener('data', onData);
+      stdout.write('\n');
+    };
+
+    const toggleMode = (mode) => {
+      if (mode === 'all') {
+        const shouldSelectAll = !VALID_MODES.every((candidate) => selected.has(candidate));
+        selected.clear();
+        if (shouldSelectAll) {
+          VALID_MODES.forEach((candidate) => selected.add(candidate));
+        }
+        return;
+      }
+
+      if (selected.has(mode)) {
+        selected.delete(mode);
+      } else {
+        selected.add(mode);
+      }
+    };
+
+    const onData = (chunk) => {
+      const value = chunk.toString('utf8');
+      if (value === '\u0003') {
+        cleanup();
+        reject(new Error('Installation cancelled.'));
+        return;
+      }
+
+      if (value === '\u001b[A' || value === 'k') {
+        cursor = (cursor - 1 + TARGET_OPTIONS.length) % TARGET_OPTIONS.length;
+        message = '';
+        renderSelectionScreen({ output: stdout, version, cursor, selected, message, env });
+        return;
+      }
+
+      if (value === '\u001b[B' || value === 'j') {
+        cursor = (cursor + 1) % TARGET_OPTIONS.length;
+        message = '';
+        renderSelectionScreen({ output: stdout, version, cursor, selected, message, env });
+        return;
+      }
+
+      if (value === ' ') {
+        toggleMode(TARGET_OPTIONS[cursor].id);
+        message = '';
+        renderSelectionScreen({ output: stdout, version, cursor, selected, message, env });
+        return;
+      }
+
+      if (value.toLowerCase() === 'a') {
+        toggleMode('all');
+        message = '';
+        renderSelectionScreen({ output: stdout, version, cursor, selected, message, env });
+        return;
+      }
+
+      if (value.toLowerCase() === 'q' || value === '\u001b') {
+        cleanup();
+        reject(new Error('Installation cancelled.'));
+        return;
+      }
+
+      if (value === '\r') {
+        if (selected.size === 0) {
+          message = 'Select at least one target before continuing.';
+          renderSelectionScreen({ output: stdout, version, cursor, selected, message, env });
+          return;
+        }
+
+        cleanup();
+        resolve([...selected]);
+      }
+    };
+
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.on('data', onData);
+    renderSelectionScreen({ output: stdout, version, cursor, selected, message, env });
+  });
+}
+
+async function confirmInstall({ stdin, stdout, version, toolkitHome, modes, env }) {
+  const colorEnabled = supportsColor(stdout, env);
+  stdout.write(`${buildBanner({ version, colorEnabled })}\n\n`);
+  stdout.write(`Apollo Toolkit home: ${toolkitHome}\n`);
+  stdout.write(`Targets: ${modes.join(', ')}\n\n`);
+
+  const targets = await getTargetRoots(modes, env).catch((error) => {
+    throw error;
+  });
+  for (const target of targets) {
+    stdout.write(`- ${target.label}: ${target.root}\n`);
+  }
+  stdout.write('\n');
+
+  if (!stdin.isTTY || !stdout.isTTY) {
+    return true;
+  }
+
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    const answer = await rl.question('Install Apollo Toolkit to these targets? [Y/n] ');
+    return answer.trim() === '' || answer.trim().toLowerCase() === 'y';
+  } finally {
+    rl.close();
+  }
+}
+
+function printSummary({ stdout, version, toolkitHome, modes, installResult, env }) {
+  const colorEnabled = supportsColor(stdout, env);
+  stdout.write(`\n${buildBanner({ version, colorEnabled })}\n\n`);
+  stdout.write(color('Installation complete.', '1;32', colorEnabled));
+  stdout.write('\n');
+  stdout.write(`Apollo Toolkit home: ${toolkitHome}\n`);
+  stdout.write(`Linked skills: ${installResult.skillNames.length}\n`);
+  stdout.write(`Targets: ${modes.join(', ')}\n\n`);
+
+  for (const target of installResult.targets) {
+    stdout.write(`- ${target.label}: ${target.root}\n`);
+  }
+}
+
+async function run(argv, context = {}) {
+  const sourceRoot = context.sourceRoot || path.resolve(__dirname, '..');
+  const stdout = context.stdout || process.stdout;
+  const stderr = context.stderr || process.stderr;
+  const stdin = context.stdin || process.stdin;
+  const env = context.env || process.env;
+  const packageJson = require(path.join(sourceRoot, 'package.json'));
+
+  try {
+    const parsed = parseArguments(argv);
+    if (parsed.showHelp) {
+      stdout.write(`${buildHelpText({ version: packageJson.version, colorEnabled: supportsColor(stdout, env) })}\n`);
+      return 0;
+    }
+
+    const toolkitHome = parsed.toolkitHome || resolveToolkitHome(env);
+    const modes = parsed.modes.length > 0
+      ? normalizeModes(parsed.modes)
+      : normalizeModes(await promptForModes({ stdin, stdout, version: packageJson.version, env }));
+
+    const confirmed = await confirmInstall({
+      stdin,
+      stdout,
+      version: packageJson.version,
+      toolkitHome,
+      modes,
+      env,
+    });
+
+    if (!confirmed) {
+      stdout.write('Installation cancelled.\n');
+      return 1;
+    }
+
+    await syncToolkitHome({
+      sourceRoot,
+      toolkitHome,
+      version: packageJson.version,
+    });
+
+    const installResult = await installLinks({
+      toolkitHome,
+      modes,
+      env: {
+        ...env,
+        APOLLO_TOOLKIT_HOME: toolkitHome,
+      },
+    });
+
+    printSummary({ stdout, version: packageJson.version, toolkitHome, modes, installResult, env });
+    return 0;
+  } catch (error) {
+    stderr.write(`Error: ${error.message}\n`);
+    return 1;
+  }
+}
+
+module.exports = {
+  buildBanner,
+  buildHelpText,
+  parseArguments,
+  promptForModes,
+  run,
+};