bmad-method 6.8.1-next.9 → 6.9.0

package/src/core-skills/bmad-brainstorming/scripts/tests/test_memlog.py

@@ -1,265 +0,0 @@
-# /// script
-# requires-python = ">=3.10"
-# dependencies = ["pytest>=8.0"]
-# ///
-"""Tests for memlog.py. Run: uv run --with pytest pytest scripts/tests/test_memlog.py
-
-The spine under test is the flat, append-only, chronological invariant: every entry is
-one line recorded at the end in the order it happened — no sections, no grouping.
-"""
-import json
-import sys
-from pathlib import Path
-
-import pytest
-
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
-import memlog  # noqa: E402
-
-MEMLOG = ".memlog.md"
-
-
-@pytest.fixture
-def ws(tmp_path):
-    return str(tmp_path)
-
-
-def read(ws):
-    return (Path(ws) / MEMLOG).read_text(encoding="utf-8")
-
-
-def body_of(ws):
-    return memlog.split(read(ws))[1]
-
-
-def entries(ws):
-    return [ln for ln in body_of(ws).splitlines() if ln.startswith("- ")]
-
-
-def init(ws, **fields):
-    fields = fields or {"topic": "Reinvent the lunchbox", "goal": "ideas for a pitch"}
-    argv = ["init", "--workspace", ws]
-    for k, v in fields.items():
-        argv += ["--field", f"{k}={v}"]
-    assert memlog.main(argv) == 0
-
-
-def append(ws, text, entry_type=None, by=None):
-    argv = ["append", "--workspace", ws, "--text", text]
-    if entry_type:
-        argv += ["--type", entry_type]
-    if by:
-        argv += ["--by", by]
-    assert memlog.main(argv) == 0
-
-
-# --- init ---------------------------------------------------------------
-
-def test_init_writes_frontmatter_fields(ws):
-    init(ws)
-    meta, body = memlog.split(read(ws))
-    assert meta["topic"] == "Reinvent the lunchbox"
-    assert meta["goal"] == "ideas for a pitch"
-    assert meta["status"] == "active"
-    assert "updated" in meta
-    assert body.strip() == ""
-
-
-def test_init_arbitrary_fields(ws):
-    init(ws, topic="T", audience="board")
-    meta, _ = memlog.split(read(ws))
-    assert meta["audience"] == "board"
-
-
-def test_init_refuses_overwrite(ws):
-    init(ws)
-    assert memlog.main(["init", "--workspace", ws, "--field", "topic=other"]) == 2
-
-
-def test_init_creates_missing_workspace(tmp_path):
-    nested = str(tmp_path / "a" / "b")
-    assert memlog.main(["init", "--workspace", nested, "--field", "topic=T"]) == 0
-    assert (Path(nested) / MEMLOG).is_file()
-
-
-def test_init_rejects_malformed_field(ws):
-    assert memlog.main(["init", "--workspace", ws, "--field", "noequals"]) == 2
-
-
-# --- append: flat chronological order is the whole point -----------------
-
-def test_append_lands_at_end_in_order(ws):
-    init(ws)
-    append(ws, "first")
-    append(ws, "second")
-    append(ws, "third")
-    assert entries(ws) == ["- first", "- second", "- third"]
-
-
-def test_no_sections_or_headings_ever(ws):
-    init(ws)
-    append(ws, "started foo", entry_type="technique")
-    append(ws, "an idea", entry_type="idea")
-    append(ws, "started bar", entry_type="technique")
-    assert "## " not in body_of(ws)  # the flat log never grows headings
-
-
-def test_type_renders_as_inline_tag(ws):
-    init(ws)
-    append(ws, "the earth revolves around the sun", entry_type="idea")
-    append(ws, "how do we handle stampede?", entry_type="question")
-    body = body_of(ws)
-    assert "- (idea) the earth revolves around the sun" in body
-    assert "- (question) how do we handle stampede?" in body
-
-
-def test_append_without_type_is_plain_note(ws):
-    init(ws)
-    append(ws, "bare entry")
-    assert entries(ws) == ["- bare entry"]
-
-
-def test_append_collapses_newlines_into_one_line(ws):
-    init(ws)
-    append(ws, "line one\nline two\n  spaced   out")
-    assert entries(ws) == ["- line one line two spaced out"]
-
-
-def test_revisited_technique_is_just_a_later_entry(ws):
-    # the user's model: switching techniques is an entry, not a section to return to
-    init(ws)
-    append(ws, "started SCAMPER", entry_type="technique")
-    append(ws, "magnetic latch", entry_type="idea")
-    append(ws, "started Six Hats", entry_type="technique")
-    append(ws, "stale data risk", entry_type="idea")
-    append(ws, "started SCAMPER", entry_type="technique")  # back to SCAMPER — just appended again
-    append(ws, "stackable tiers", entry_type="idea")
-    assert entries(ws) == [
-        "- (technique) started SCAMPER",
-        "- (idea) magnetic latch",
-        "- (technique) started Six Hats",
-        "- (idea) stale data risk",
-        "- (technique) started SCAMPER",
-        "- (idea) stackable tiers",
-    ]
-
-
-def test_by_renders_attribution_in_tag(ws):
-    # Creative Partner mode must record whose idea each one was
-    init(ws)
-    append(ws, "magnetic latch lid", entry_type="idea", by="user")
-    append(ws, "lid doubles as a plate", entry_type="idea", by="coach")
-    body = body_of(ws)
-    assert "- (idea by user) magnetic latch lid" in body
-    assert "- (idea by coach) lid doubles as a plate" in body
-
-
-def test_by_without_type_renders_alone(ws):
-    init(ws)
-    append(ws, "off-the-cuff thought", by="coach")
-    assert entries(ws) == ["- (by coach) off-the-cuff thought"]
-
-
-def test_heterogeneous_entry_types_coexist(ws):
-    init(ws)
-    append(ws, "an idea", entry_type="idea")
-    append(ws, "an open question", entry_type="question")
-    append(ws, "a decision we made", entry_type="decision")
-    append(ws, "user wants mobile-first", entry_type="direction")
-    body = body_of(ws)
-    for tag in ("(idea)", "(question)", "(decision)", "(direction)"):
-        assert tag in body
-
-
-# --- set ----------------------------------------------------------------
-
-def test_set_flips_status(ws):
-    init(ws)
-    memlog.main(["set", "--workspace", ws, "--key", "status", "--value", "complete"])
-    assert memlog.split(read(ws))[0]["status"] == "complete"
-
-
-def test_set_preserves_body(ws):
-    init(ws)
-    append(ws, "keep me", entry_type="idea")
-    memlog.main(["set", "--workspace", ws, "--key", "status", "--value", "complete"])
-    meta, body = memlog.split(read(ws))
-    assert meta["status"] == "complete"
-    assert "- (idea) keep me" in body
-
-
-def test_set_can_add_new_field(ws):
-    init(ws)
-    memlog.main(["set", "--workspace", ws, "--key", "owner", "--value", "BMad"])
-    assert memlog.split(read(ws))[0]["owner"] == "BMad"
-
-
-def test_updated_stays_last(ws):
-    init(ws)
-    memlog.main(["set", "--workspace", ws, "--key", "owner", "--value", "BMad"])
-    meta = memlog.split(read(ws))[0]
-    assert list(meta)[-1] == "updated"
-
-
-# --- robustness ---------------------------------------------------------
-
-def test_roundtrip_render_is_stable(ws):
-    init(ws)
-    append(ws, "one", entry_type="idea")
-    first = read(ws)
-    meta, body = memlog.split(first)
-    assert memlog.render(meta, body) == first
-
-
-def test_commas_in_field_survive(ws):
-    init(ws, topic="cars, trains, and planes")
-    append(ws, "z", entry_type="idea")
-    meta, _ = memlog.split(read(ws))
-    assert meta["topic"] == "cars, trains, and planes"
-
-
-def test_triple_dash_in_field_does_not_corrupt_frontmatter(ws):
-    # A `---` inside a value must NOT be read as the closing fence: topic stays intact,
-    # status survives, and the body never leaks frontmatter text.
-    init(ws, topic="Pricing --- tiers --- and add-ons")
-    append(ws, "an idea", entry_type="idea")
-    meta, body = memlog.split(read(ws))
-    assert meta["topic"] == "Pricing --- tiers --- and add-ons"
-    assert meta["status"] == "active"
-    assert entries(ws) == ["- (idea) an idea"]
-    assert "status:" not in body  # frontmatter never bled into the body
-
-
-def test_triple_dash_status_survives_in_ack(ws, capsys):
-    init(ws, topic="a --- b")
-    append(ws, "x", entry_type="idea")
-    out = json.loads(capsys.readouterr().out.strip().splitlines()[-1])
-    assert out["status"] == "active"  # not "" — frontmatter recovered cleanly
-
-
-def test_newline_in_field_is_neutralized(ws):
-    # A value carrying a newline can't break the fence on the next round-trip.
-    memlog.main(["init", "--workspace", ws, "--field", "topic=line one\nline two"])
-    append(ws, "x", entry_type="idea")
-    meta, _ = memlog.split(read(ws))
-    assert "\n" not in meta["topic"]
-    assert meta["status"] == "active"
-
-
-def test_append_emits_json_ack(ws, capsys):
-    init(ws)
-    append(ws, "x", entry_type="idea")
-    out = json.loads(capsys.readouterr().out.strip().splitlines()[-1])
-    assert out["ok"] is True
-    assert out["status"] == "active"
-    assert out["entries"] == 1
-    assert out["memlog"].endswith(MEMLOG)
-    assert "section" not in out  # sections are gone
-
-
-def test_ack_entry_count_climbs(ws, capsys):
-    init(ws)
-    append(ws, "a")
-    append(ws, "b")
-    out = json.loads(capsys.readouterr().out.strip().splitlines()[-1])
-    assert out["entries"] == 2

package/tools/installer/core/python-check.js

@@ -1,199 +0,0 @@
-const { spawnSync } = require('node:child_process');
-const prompts = require('../prompts');
-
-// Python 3.11 added stdlib `tomllib` (PEP 680), which the shared scripts in
-// src/scripts/ (resolve_config.py, resolve_customization.py) require to read
-// BMAD's TOML config files. memlog.py is more lenient and runs on 3.8+.
-const PYTHON_FULL_SUPPORT = { major: 3, minor: 11 };
-const PYTHON_PARTIAL_SUPPORT = { major: 3, minor: 8 };
-
-// Every runtime call site (skill steps, on_complete hooks) invokes a literal
-// `python3`, so only that command's version vouches for BMAD features. The
-// fallback probes exist to tell the user "Python is installed, but not under
-// the name BMAD uses" instead of a misleading "No Python found".
-const RUNTIME_COMMAND = 'python3';
-const PROBE_CANDIDATES =
-  process.platform === 'win32'
-    ? [
-        { command: 'python3', args: ['--version'] },
-        { command: 'py', args: ['-3', '--version'] },
-        { command: 'python', args: ['--version'] },
-      ]
-    : [
-        { command: 'python3', args: ['--version'] },
-        { command: 'python', args: ['--version'] },
-      ];
-
-/**
- * Parse a `python --version` output line into version parts.
- * Python 3 prints to stdout; Python 2 printed to stderr — callers pass both.
- * @param {string} output - Combined stdout/stderr from `python --version`
- * @returns {{major: number, minor: number, patch: number, raw: string}|null}
- */
-function parsePythonVersion(output) {
-  if (!output) return null;
-  const match = output.match(/Python\s+(\d+)\.(\d+)(?:\.(\d+))?/);
-  if (!match) return null;
-  return {
-    major: Number(match[1]),
-    minor: Number(match[2]),
-    patch: Number(match[3] || 0),
-    raw: `${match[1]}.${match[2]}.${match[3] || 0}`,
-  };
-}
-
-/**
- * Classify a detected Python version against BMAD's feature requirements.
- * @param {{major: number, minor: number}|null} version
- * @returns {'full'|'partial'|'unsupported'|'none'}
- */
-function classifyPython(version) {
-  if (!version) return 'none';
-  const { major, minor } = version;
-  if (major > PYTHON_FULL_SUPPORT.major || (major === PYTHON_FULL_SUPPORT.major && minor >= PYTHON_FULL_SUPPORT.minor)) {
-    return 'full';
-  }
-  if (major === PYTHON_PARTIAL_SUPPORT.major && minor >= PYTHON_PARTIAL_SUPPORT.minor) {
-    return 'partial';
-  }
-  return 'unsupported';
-}
-
-/**
- * Run one probe candidate and return its parsed version, or null.
- * @param {{command: string, args: string[]}} candidate
- * @returns {{major: number, minor: number, patch: number, raw: string}|null}
- */
-function probeVersion(candidate) {
-  const run = (extra = {}) =>
-    spawnSync(candidate.command, candidate.args, {
-      encoding: 'utf8',
-      timeout: 5000,
-      windowsHide: true,
-      ...extra,
-    });
-  let result = run();
-  // Node >=18.20/20.12 refuses to spawn .bat/.cmd without a shell
-  // (CVE-2024-27980 hardening) and reports EINVAL — pyenv-win ships its
-  // python shims as .bat. Args here are static literals, so a shell retry
-  // is injection-safe.
-  if (result.error && result.error.code === 'EINVAL' && process.platform === 'win32') {
-    result = run({ shell: true });
-  }
-  if (result.error) return null;
-  return parsePythonVersion(`${result.stdout || ''}\n${result.stderr || ''}`);
-}
-
-/**
- * Probe the local environment for a Python interpreter.
- * Tries each candidate command and returns the first that reports a version.
- * `isRuntimeCommand` is true only when the match is `python3` — the command
- * BMAD scripts actually invoke.
- * @returns {{command: string, version: {major: number, minor: number, patch: number, raw: string}, isRuntimeCommand: boolean}|null}
- */
-function detectPython() {
-  for (const candidate of PROBE_CANDIDATES) {
-    try {
-      const version = probeVersion(candidate);
-      if (version) {
-        const display = candidate.args.length > 1 ? `${candidate.command} ${candidate.args.slice(0, -1).join(' ')}` : candidate.command;
-        return { command: display, version, isRuntimeCommand: candidate.command === RUNTIME_COMMAND };
-      }
-    } catch {
-      // Candidate not runnable — try the next one.
-    }
-  }
-  return null;
-}
-
-function upgradeHints() {
-  return [
-    'How to get Python 3.11+ (as `python3`):',
-    '  macOS:        brew install python3',
-    '  Windows:      winget install Python.Python.3.12  (then ensure `python3` resolves, e.g. enable the python3 alias)',
-    '  Linux/WSL:    sudo apt install python3  (Ubuntu 24.04+ ships 3.12; older distros: use pyenv or deadsnakes)',
-    '  Docker:       add python3 to your image (e.g. apk add python3 / apt-get install -y python3)',
-  ].join('\n');
-}
-
-/**
- * Check the local Python environment and warn about degraded BMAD features.
- *
- * Warn-don't-block: most of BMAD works without Python, so the install always
- * may proceed — but the user must explicitly acknowledge the warning so it
- * can't scroll past unseen. In non-interactive runs (--yes, or stdin is not
- * a TTY) the warning is logged and the install continues without a prompt.
- *
- * @param {Object} [options]
- * @param {boolean} [options.nonInteractive=false] - Skip the ack prompt (--yes, or no TTY)
- * @returns {Promise<{status: string, detected: Object|null}>}
- */
-async function checkPythonEnvironment({ nonInteractive = false } = {}) {
-  // Called via module.exports so tests can stub detection.
-  const detected = module.exports.detectPython();
-  const status = classifyPython(detected ? detected.version : null);
-
-  if (status === 'full' && detected.isRuntimeCommand) {
-    await prompts.log.success(`Python ${detected.version.raw} detected (${detected.command}) — all BMAD features supported.`);
-    return { status, detected };
-  }
-
-  if (detected && !detected.isRuntimeCommand) {
-    await prompts.log.warn(
-      `Python ${detected.version.raw} found via \`${detected.command}\`, but BMAD scripts invoke \`python3\`, which is not on PATH.\n` +
-        `Python-powered features (memlog session memory, TOML config resolution) won't run until \`python3\` resolves —\n` +
-        `add a python3 alias/shim, or reinstall Python with the python3 launcher enabled.`,
-    );
-  } else if (status === 'partial') {
-    await prompts.log.warn(
-      `Python ${detected.version.raw} detected (${detected.command}) — BMAD's TOML config tools need Python 3.11+ (stdlib tomllib).\n` +
-        `Works: memlog session memory. Won't work: config/customization resolution scripts.`,
-    );
-  } else {
-    const found =
-      status === 'unsupported' ? `Python ${detected.version.raw} detected (${detected.command}) — too old.` : 'No Python found on PATH.';
-    await prompts.log.warn(
-      `${found} BMAD installs fine without it, but Python-powered features\n` +
-        `(memlog session memory, TOML config resolution) won't run until Python 3.11+ is available.`,
-    );
-  }
-  await prompts.note(upgradeHints(), 'Python 3.11+ recommended');
-
-  if (nonInteractive) {
-    await prompts.log.info('Continuing anyway (non-interactive run). You can fix Python later — no reinstall needed.');
-    return { status, detected };
-  }
-
-  const choice = await prompts.select({
-    message: "BMAD's Python-powered features won't work yet. How do you want to proceed?",
-    choices: [
-      {
-        name: 'Continue install',
-        value: 'continue',
-        hint: 'BMAD works without Python — you can fix Python later, no reinstall needed',
-      },
-      {
-        name: 'Quit and fix Python first',
-        value: 'quit',
-        hint: 'make Python 3.11+ available as python3, then re-run the installer',
-      },
-    ],
-    default: 'continue',
-  });
-
-  if (choice === 'quit') {
-    await prompts.cancel('Make Python 3.11+ available as `python3` (see hints above), then re-run the installer.');
-    process.exit(0);
-  }
-
-  return { status, detected };
-}
-
-module.exports = {
-  checkPythonEnvironment,
-  detectPython,
-  parsePythonVersion,
-  classifyPython,
-  PYTHON_FULL_SUPPORT,
-  PYTHON_PARTIAL_SUPPORT,
-};