@laitszkin/apollo-toolkit 3.13.2 → 3.14.0

package/generate-spec/scripts/create-specs

@@ -1,215 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import argparse
-import re
-from datetime import date
-from pathlib import Path
-
-TEMPLATE_FILENAMES = (
-    "spec.md",
-    "tasks.md",
-    "checklist.md",
-    "contract.md",
-    "design.md",
-)
-COORDINATION_TEMPLATE = "coordination.md"
-PREPARATION_TEMPLATE = "preparation.md"
-PLACEHOLDERS = ("[Feature Name]", "[功能名稱]")
-
-
-def _slugify(text: str) -> str:
-    slug = text.lower().strip()
-    slug = re.sub(r"[^a-z0-9]+", "-", slug)
-    slug = re.sub(r"-+", "-", slug).strip("-")
-    return slug
-
-
-def _default_template_dir() -> Path:
-    return Path(__file__).resolve().parent.parent / "references" / "templates"
-
-
-def _render(
-    content: str,
-    today: str,
-    feature_name: str,
-    change_name: str,
-    batch_name: str | None,
-) -> str:
-    rendered = content.replace("[YYYY-MM-DD]", today)
-    for placeholder in PLACEHOLDERS:
-        rendered = rendered.replace(placeholder, feature_name)
-    rendered = rendered.replace("[change_name]", change_name)
-    rendered = rendered.replace("[batch_name]", batch_name or "None")
-    return rendered
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(
-        description=(
-            "Create planning docs (spec.md, tasks.md, checklist.md, contract.md, design.md) "
-            "from templates with folder format docs/plans/{date}/{change_name} "
-            "or docs/plans/{date}/{batch_name}/{change_name}, including coordination "
-            "and optional preparation templates for batch specs that need shared "
-            "pre-work before parallel implementation."
-        ),
-    )
-    parser.add_argument("feature_name", help="Display name used in generated documents")
-    parser.add_argument(
-        "--change-name",
-        "--slug",
-        dest="change_name",
-        help=(
-            "Folder name part used after date. "
-            "Defaults to slugified feature_name when omitted."
-        ),
-    )
-    parser.add_argument(
-        "--batch-name",
-        help=(
-            "Optional batch folder used for parallel spec generation. "
-            "When provided, specs are written under docs/plans/{date}/{batch_name}/{change_name}."
-        ),
-    )
-    parser.add_argument(
-        "--with-coordination",
-        action="store_true",
-        help=(
-            "When used with --batch-name, also create or update "
-            "docs/plans/{date}/{batch_name}/coordination.md from the shared template "
-            "for up-front ownership and collision coordination."
-        ),
-    )
-    parser.add_argument(
-        "--with-preparation",
-        action="store_true",
-        help=(
-            "When used with --batch-name, also create or update "
-            "docs/plans/{date}/{batch_name}/preparation.md from the shared template "
-            "for prerequisite work that must be completed before parallel implementation."
-        ),
-    )
-    parser.add_argument(
-        "--output-dir",
-        default="docs/plans",
-        help="Output directory (default: docs/plans)",
-    )
-    parser.add_argument(
-        "--template-dir",
-        default=str(_default_template_dir()),
-        help="Directory containing planning document templates",
-    )
-    parser.add_argument(
-        "--force",
-        action="store_true",
-        help="Overwrite existing files if present",
-    )
-    args = parser.parse_args()
-
-    feature_name = args.feature_name.strip()
-    if not feature_name:
-        raise SystemExit("feature_name cannot be empty")
-
-    change_name = (
-        args.change_name.strip() if args.change_name else _slugify(feature_name)
-    )
-    if not change_name:
-        raise SystemExit(
-            "Unable to build change_name. Provide --change-name with ASCII letters/numbers."
-        )
-
-    batch_name = args.batch_name.strip() if args.batch_name else None
-    if args.with_coordination and not batch_name:
-        raise SystemExit("--with-coordination requires --batch-name")
-    if args.with_preparation and not batch_name:
-        raise SystemExit("--with-preparation requires --batch-name")
-
-    template_dir = Path(args.template_dir).expanduser().resolve()
-    if not template_dir.exists() or not template_dir.is_dir():
-        raise SystemExit(f"Template directory not found: {template_dir}")
-
-    missing_templates = [
-        name for name in TEMPLATE_FILENAMES if not (template_dir / name).exists()
-    ]
-    if args.with_coordination and not (template_dir / COORDINATION_TEMPLATE).exists():
-        missing_templates.append(COORDINATION_TEMPLATE)
-    if args.with_preparation and not (template_dir / PREPARATION_TEMPLATE).exists():
-        missing_templates.append(PREPARATION_TEMPLATE)
-    if missing_templates:
-        missing = ", ".join(missing_templates)
-        raise SystemExit(f"Missing template files in {template_dir}: {missing}")
-
-    output_dir = Path(args.output_dir).expanduser().resolve()
-    today = date.today().isoformat()
-    date_root = output_dir / today
-    batch_root = date_root / batch_name if batch_name else None
-    output_root = (batch_root / change_name) if batch_root else (date_root / change_name)
-
-    output_paths = [output_root / name for name in TEMPLATE_FILENAMES]
-    coordination_path = (
-        batch_root / COORDINATION_TEMPLATE if args.with_coordination and batch_root else None
-    )
-    preparation_path = (
-        batch_root / PREPARATION_TEMPLATE if args.with_preparation and batch_root else None
-    )
-    existing_files = [path for path in output_paths if path.exists()]
-    if existing_files and not args.force:
-        existing = ", ".join(str(path) for path in existing_files)
-        raise SystemExit(
-            f"Files already exist: {existing}. Use --force to overwrite existing files."
-        )
-
-    output_root.mkdir(parents=True, exist_ok=True)
-
-    for filename in TEMPLATE_FILENAMES:
-        template_path = template_dir / filename
-        output_path = output_root / filename
-        content = template_path.read_text(encoding="utf-8")
-        output_path.write_text(
-            _render(
-                content=content,
-                today=today,
-                feature_name=feature_name,
-                change_name=change_name,
-                batch_name=batch_name,
-            ),
-            encoding="utf-8",
-        )
-
-    if coordination_path and (args.force or not coordination_path.exists()):
-        coordination_template = template_dir / COORDINATION_TEMPLATE
-        coordination_path.write_text(
-            _render(
-                content=coordination_template.read_text(encoding="utf-8"),
-                today=today,
-                feature_name=feature_name,
-                change_name=change_name,
-                batch_name=batch_name,
-            ),
-            encoding="utf-8",
-        )
-
-    if preparation_path and (args.force or not preparation_path.exists()):
-        preparation_template = template_dir / PREPARATION_TEMPLATE
-        preparation_path.write_text(
-            _render(
-                content=preparation_template.read_text(encoding="utf-8"),
-                today=today,
-                feature_name=feature_name,
-                change_name=change_name,
-                batch_name=batch_name,
-            ),
-            encoding="utf-8",
-        )
-
-    for output_path in output_paths:
-        print(output_path)
-    if coordination_path:
-        print(coordination_path)
-    if preparation_path:
-        print(preparation_path)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/generate-spec/tests/test_create_specs.py

@@ -1,200 +0,0 @@
-#!/usr/bin/env python3
-
-from __future__ import annotations
-
-import importlib.machinery
-import importlib.util
-import io
-import random
-import re
-import string
-import sys
-import tempfile
-import unittest
-from datetime import date
-from pathlib import Path
-from unittest.mock import patch
-
-
-SCRIPT_PATH = Path(__file__).resolve().parents[1] / "scripts" / "create-specs"
-LOADER = importlib.machinery.SourceFileLoader("create_specs", str(SCRIPT_PATH))
-SPEC = importlib.util.spec_from_loader("create_specs", LOADER)
-MODULE = importlib.util.module_from_spec(SPEC)
-SPEC.loader.exec_module(MODULE)
-
-
-class FixedDate(date):
-    @classmethod
-    def today(cls) -> "FixedDate":
-        return cls(2026, 4, 18)
-
-
-class CreateSpecsTests(unittest.TestCase):
-    def test_slugify_property_keeps_safe_slug_shape(self) -> None:
-        alphabet = string.ascii_letters + string.digits + string.punctuation + " \t中文"
-        generator = random.Random(20260418)
-
-        for _ in range(250):
-            raw = "".join(generator.choice(alphabet) for _ in range(generator.randint(0, 40)))
-            slug = MODULE._slugify(raw)
-            with self.subTest(raw=raw, slug=slug):
-                self.assertEqual(slug, slug.lower())
-                self.assertNotIn("--", slug)
-                self.assertFalse(slug.startswith("-"))
-                self.assertFalse(slug.endswith("-"))
-                self.assertRegex(slug, r"^[a-z0-9-]*$")
-
-    def test_render_replaces_all_placeholders(self) -> None:
-        rendered = MODULE._render(
-            content=(
-                "[YYYY-MM-DD]\n"
-                "[Feature Name]\n"
-                "[功能名稱]\n"
-                "[change_name]\n"
-                "[batch_name]\n"
-            ),
-            today="2026-04-18",
-            feature_name="Batch-safe planner",
-            change_name="batch-safe-planner",
-            batch_name="parallel-batch",
-        )
-
-        self.assertIn("2026-04-18", rendered)
-        self.assertEqual(rendered.count("Batch-safe planner"), 2)
-        self.assertIn("batch-safe-planner", rendered)
-        self.assertIn("parallel-batch", rendered)
-
-    def test_main_creates_spec_files_and_shared_batch_files(self) -> None:
-        with tempfile.TemporaryDirectory() as temp_dir:
-            root = Path(temp_dir)
-            template_dir = root / "templates"
-            output_dir = root / "docs" / "plans"
-            template_dir.mkdir(parents=True)
-
-            for name in MODULE.TEMPLATE_FILENAMES:
-                (template_dir / name).write_text(
-                    f"{name} [YYYY-MM-DD] [Feature Name] [change_name] [batch_name]\n",
-                    encoding="utf-8",
-                )
-            (template_dir / MODULE.COORDINATION_TEMPLATE).write_text(
-                "coordination [YYYY-MM-DD] [Feature Name] [change_name] [batch_name]\n",
-                encoding="utf-8",
-            )
-            (template_dir / MODULE.PREPARATION_TEMPLATE).write_text(
-                "preparation [YYYY-MM-DD] [Feature Name] [change_name] [batch_name]\n",
-                encoding="utf-8",
-            )
-
-            argv = [
-                "create-specs",
-                "My Feature",
-                "--batch-name",
-                "parallel-batch",
-                "--with-coordination",
-                "--with-preparation",
-                "--output-dir",
-                str(output_dir),
-                "--template-dir",
-                str(template_dir),
-            ]
-
-            with patch.object(MODULE, "date", FixedDate), patch.object(sys, "argv", argv), patch(
-                "sys.stdout", new_callable=io.StringIO
-            ) as stdout:
-                exit_code = MODULE.main()
-
-            self.assertEqual(exit_code, 0)
-            change_root = output_dir / "2026-04-18" / "parallel-batch" / "my-feature"
-            for name in MODULE.TEMPLATE_FILENAMES:
-                content = (change_root / name).read_text(encoding="utf-8")
-                self.assertIn("2026-04-18", content)
-                self.assertIn("My Feature", content)
-                self.assertIn("my-feature", content)
-                self.assertIn("parallel-batch", content)
-
-            coordination = output_dir / "2026-04-18" / "parallel-batch" / "coordination.md"
-            self.assertTrue(coordination.is_file())
-            self.assertIn(str(coordination), stdout.getvalue())
-            preparation = output_dir / "2026-04-18" / "parallel-batch" / "preparation.md"
-            self.assertTrue(preparation.is_file())
-            self.assertIn("preparation", preparation.read_text(encoding="utf-8"))
-            self.assertIn(str(preparation), stdout.getvalue())
-
-    def test_main_requires_batch_name_for_preparation_file(self) -> None:
-        with tempfile.TemporaryDirectory() as temp_dir:
-            template_dir = Path(temp_dir) / "templates"
-            template_dir.mkdir(parents=True)
-            for name in MODULE.TEMPLATE_FILENAMES:
-                (template_dir / name).write_text("template\n", encoding="utf-8")
-            (template_dir / MODULE.PREPARATION_TEMPLATE).write_text(
-                "preparation\n",
-                encoding="utf-8",
-            )
-
-            argv = [
-                "create-specs",
-                "My Feature",
-                "--with-preparation",
-                "--template-dir",
-                str(template_dir),
-            ]
-
-            with patch.object(sys, "argv", argv):
-                with self.assertRaises(SystemExit) as context:
-                    MODULE.main()
-
-            self.assertIn("--with-preparation requires --batch-name", str(context.exception))
-
-    def test_main_rejects_existing_files_without_force(self) -> None:
-        with tempfile.TemporaryDirectory() as temp_dir:
-            root = Path(temp_dir)
-            template_dir = root / "templates"
-            output_dir = root / "docs" / "plans"
-            template_dir.mkdir(parents=True)
-            for name in MODULE.TEMPLATE_FILENAMES:
-                (template_dir / name).write_text("template\n", encoding="utf-8")
-
-            existing_root = output_dir / "2026-04-18" / "existing-change"
-            existing_root.mkdir(parents=True)
-            (existing_root / "spec.md").write_text("existing\n", encoding="utf-8")
-
-            argv = [
-                "create-specs",
-                "Existing Change",
-                "--change-name",
-                "existing-change",
-                "--output-dir",
-                str(output_dir),
-                "--template-dir",
-                str(template_dir),
-            ]
-
-            with patch.object(MODULE, "date", FixedDate), patch.object(sys, "argv", argv):
-                with self.assertRaises(SystemExit) as context:
-                    MODULE.main()
-
-            self.assertIn("Files already exist", str(context.exception))
-
-    def test_main_requires_explicit_ascii_change_name_when_slug_is_empty(self) -> None:
-        with tempfile.TemporaryDirectory() as temp_dir:
-            template_dir = Path(temp_dir) / "templates"
-            template_dir.mkdir(parents=True)
-            for name in MODULE.TEMPLATE_FILENAMES:
-                (template_dir / name).write_text("template\n", encoding="utf-8")
-
-            argv = [
-                "create-specs",
-                "功能名稱",
-                "--template-dir",
-                str(template_dir),
-            ]
-
-            with patch.object(sys, "argv", argv):
-                with self.assertRaises(SystemExit) as context:
-                    MODULE.main()
-
-            self.assertIn("Unable to build change_name", str(context.exception))
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,16 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-// One-shot helper: `node architecture-bootstrap-render.js render --project <root> ...`
-// Invoked synchronously from architecture.js (legacy open) when index.html is missing
-// so the sync `main()` can still bootstrap an empty tree without duplicating elk layout.
-
-const cli = require('../lib/atlas/cli');
-
-(async () => {
-  const code = await cli.dispatch(process.argv.slice(2));
-  process.exit(typeof code === 'number' ? code : 1);
-})().catch((err) => {
-  process.stderr.write(`${err && err.stack ? err.stack : err}\n`);
-  process.exit(1);
-});