workstream-cli 0.0.1__py3-none-any.whl

workstream/test/test_next.py

@@ -0,0 +1,206 @@
+"""Tests for ws next and ws stale commands."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from workstream.commands.next_cmd import get_next_workstreams
+from workstream.commands.stale import get_stale_workstreams
+
+
+# -- ws next ----------------------------------------------------------------
+
+class TestGetNextWorkstreams:
+    def test_next_all_active(self, workstreams_dir: Path) -> None:
+        """Returns only active workstreams, sorted by staleness (most idle first)."""
+        results = get_next_workstreams(workstreams_dir)
+
+        # Only active status (not snoozed)
+        assert all(ws.status == 'active' for ws in results)
+        assert len(results) == 4
+
+        # Sorted by days_idle descending
+        idle_values = [ws.days_idle() for ws in results]
+        assert idle_values == sorted(idle_values, reverse=True)
+
+        # Verify relative ordering: sponsorship (oldest updated) before docs before api
+        titles = [ws.title for ws in results]
+        assert titles.index('Sponsorship Outreach') < titles.index('Docs Overhaul')
+        assert titles.index('Docs Overhaul') < titles.index('API Redesign')
+
+    def test_next_filter_by_tag(self, workstreams_dir: Path) -> None:
+        """--tag code shows only code-tagged active workstreams."""
+        results = get_next_workstreams(workstreams_dir, tag='code')
+
+        assert all(ws.status == 'active' for ws in results)
+        assert all('code' in ws.tags for ws in results)
+        # Accessibility Audit has 'code' tag and is now active — included
+        # API Redesign, Docs Overhaul, and Accessibility Audit are active + code-tagged
+        titles = {ws.title for ws in results}
+        assert 'API Redesign' in titles
+        assert 'Docs Overhaul' in titles
+        assert 'Accessibility Audit' in titles
+        assert len(results) == 3
+
+    def test_next_filter_by_size(self, workstreams_dir: Path) -> None:
+        """--size week shows only week-sized active workstreams."""
+        results = get_next_workstreams(workstreams_dir, size='week')
+
+        assert all(ws.status == 'active' for ws in results)
+        assert all(ws.size == 'week' for ws in results)
+        titles = {ws.title for ws in results}
+        assert 'API Redesign' in titles
+        assert 'Sponsorship Outreach' in titles
+        assert len(results) == 2
+
+    def test_next_empty(self, workstreams_dir: Path) -> None:
+        """Filter combination that matches nothing returns empty list."""
+        results = get_next_workstreams(workstreams_dir, tag='nonexistent')
+        assert results == []
+
+
+# -- ws stale ---------------------------------------------------------------
+
+class TestGetStaleWorkstreams:
+    def test_stale_default(self, workstreams_dir: Path) -> None:
+        """With default 7-day threshold, identifies stale active + snoozed items."""
+        snoozed_stale, active_idle, _snoozed, _needs_dir, _blocked = get_stale_workstreams(workstreams_dir, days=7)
+
+        # Conference Talk is snoozed, updated 2026-03-12 (>7 days from any date after 2026-03-19)
+        snoozed_titles = {ws.title for ws in snoozed_stale}
+        assert 'Conference Talk' in snoozed_titles
+
+        # At least some active items should be idle >7 days
+        # Sponsorship Outreach updated 2026-03-18, Docs Overhaul updated 2026-03-22
+        active_titles = {ws.title for ws in active_idle}
+        # Sponsorship is definitely stale (16+ days)
+        assert 'Sponsorship Outreach' in active_titles
+
+        # Active idle should be sorted by staleness
+        idle_values = [ws.days_idle() for ws in active_idle]
+        assert idle_values == sorted(idle_values, reverse=True)
+
+    def test_stale_snoozed_shown(self, workstreams_dir: Path) -> None:
+        """Snoozed items appear in the snoozed_stale list, not active_idle."""
+        snoozed_stale, active_idle, _snoozed, _needs_dir, _blocked = get_stale_workstreams(workstreams_dir, days=1)
+
+        snoozed_ids = {ws.id for ws in snoozed_stale}
+        active_ids = {ws.id for ws in active_idle}
+
+        # Conference Talk is snoozed — must be in snoozed, not active
+        assert '2026-03-01-c3d4e5f6a7' in snoozed_ids
+        assert '2026-03-01-c3d4e5f6a7' not in active_ids
+
+        # Active items must all be status == 'active'
+        assert all(ws.status == 'active' for ws in active_idle)
+
+    def test_stale_high_threshold(self, workstreams_dir: Path) -> None:
+        """Very high threshold returns nothing stale."""
+        snoozed_stale, active_idle, _snoozed, _needs_dir, _blocked = get_stale_workstreams(workstreams_dir, days=9999)
+        assert snoozed_stale == []
+        assert active_idle == []
+
+
+
+# -- ws next with blocked workstreams -------------------------------------------
+
+def test_next_includes_blocked(tmp_path: Path) -> None:
+    """Blocked workstreams appear in ws next output (they're in ACTIVE_STATUSES)."""
+    from workstream.commands.new import _new_handler
+    from workstream.commands.block import _block_handler
+    from workstream.config import Config
+
+    ws_dir = tmp_path / 'workstreams'
+    ws_dir.mkdir()
+    config = Config(workstreams_dir=str(ws_dir))
+
+    _new_handler(posargs_=('Active', 'Task'), config=config, size='day')
+    _new_handler(posargs_=('Blocked', 'Task'), config=config, size='day')
+
+    from workstream.markdown import load_workstream
+    files = sorted(ws_dir.glob('*.md'))
+    blocked_ws = load_workstream(files[1])
+    _block_handler(posargs_=(blocked_ws.id, 'stuck'), config=config)
+
+    results = get_next_workstreams(ws_dir)
+    titles = {ws.title for ws in results}
+    assert 'Active Task' in titles
+    assert 'Blocked Task' in titles
+    statuses = {ws.status for ws in results}
+    assert 'blocked' in statuses
+
+
+# -- ws next prompt includes log entries ------------------------------------------
+
+def test_prompt_includes_log_entries(tmp_path: Path) -> None:
+    """_build_recommendation_prompt() output contains recent log entries."""
+    from workstream.commands.new import _new_handler
+    from workstream.commands.checkin import _checkin_handler
+    from workstream.commands.next_cmd import _build_recommendation_prompt
+    from workstream.config import Config
+    from workstream.markdown import load_workstream
+
+    ws_dir = tmp_path / 'workstreams'
+    ws_dir.mkdir()
+    config = Config(workstreams_dir=str(ws_dir))
+
+    _new_handler(posargs_=('Logged', 'Task'), config=config, size='day')
+    files = list(ws_dir.glob('*.md'))
+    ws = load_workstream(files[0])
+    ws_id = ws.id
+
+    _checkin_handler(posargs_=(ws_id, 'Published', 'the', 'post'), config=config)
+
+    # Reload all workstreams to pick up log entries
+    workstreams = [load_workstream(f) for f in ws_dir.glob('*.md')]
+    prompt = _build_recommendation_prompt(workstreams, None, None)
+    assert 'Recent log:' in prompt
+    assert 'checked-in' in prompt
+    assert 'Published the post' in prompt
+
+
+# -- _build_next_manifest with sprint context -----------------------------------
+
+def test_build_next_manifest_includes_sprint_context(tmp_path: Path) -> None:
+    """Sprint context appears in the interactive manifest when provided."""
+    from workstream.commands.new import _new_handler
+    from workstream.commands.next_cmd import _build_next_manifest
+    from workstream.config import Config
+    from workstream.markdown import load_workstream
+
+    ws_dir = tmp_path / 'workstreams'
+    ws_dir.mkdir()
+    config = Config(workstreams_dir=str(ws_dir))
+    _new_handler(posargs_=('Test', 'WS'), config=config, size='day')
+
+    workstreams = [load_workstream(f) for f in ws_dir.glob('*.md')]
+    sprint_ctx = '## Sprint Note Changes\n\n```diff\n+ Done: Test task\n```'
+    manifest = _build_next_manifest(workstreams, None, None, sprint_context=sprint_ctx)
+    assert 'Sprint Note Changes' in manifest
+    assert 'Done: Test task' in manifest
+
+
+def test_build_next_manifest_no_sprint_context(tmp_path: Path) -> None:
+    """Without sprint context the manifest omits sprint information."""
+    from workstream.commands.new import _new_handler
+    from workstream.commands.next_cmd import _build_next_manifest
+    from workstream.config import Config
+    from workstream.markdown import load_workstream
+
+    ws_dir = tmp_path / 'workstreams'
+    ws_dir.mkdir()
+    config = Config(workstreams_dir=str(ws_dir))
+    _new_handler(posargs_=('Test', 'WS'), config=config, size='day')
+
+    workstreams = [load_workstream(f) for f in ws_dir.glob('*.md')]
+    manifest = _build_next_manifest(workstreams, None, None)
+    assert 'Sprint' not in manifest
+
+
+# -- get_command registration ---------------------------------------------------
+
+def test_get_command_creates_successfully() -> None:
+    """get_command() returns a valid 'next' command with --quick flag."""
+    from workstream.commands.next_cmd import get_command
+    cmd = get_command()
+    assert cmd.name == 'next'

workstream/test/test_plan_index.py

@@ -0,0 +1,83 @@
+"""Tests for workstream.plan_index — durable plan catalog."""
+
+from pathlib import Path
+
+from workstream.plan_index import load_plan_index, save_plan_index, update_plan_index
+from workstream.models import PlanRef
+
+
+def test_load_missing_file(tmp_path: Path):
+    assert load_plan_index(tmp_path) == {}
+
+
+def test_save_and_load_roundtrip(tmp_path: Path):
+    index = {
+        'my-ws': [
+            {'repo': 'r', 'path': 'p.md', 'title': 'T', 'status': 'active', 'created': '2026-01-01'},
+        ],
+    }
+    save_plan_index(index, tmp_path)
+    loaded = load_plan_index(tmp_path)
+    assert loaded == index
+    # Verify header comment
+    text = (tmp_path / 'plan-index.yaml').read_text(encoding='utf-8')
+    assert 'maintained by ws sweep' in text
+    assert 'git log' in text
+
+
+def test_update_appends_new_entries(tmp_path: Path):
+    index: dict = {}
+    plan = PlanRef(repo='r', path='a.md', status='active', title='A', date='2026-01-01')
+    changed = update_plan_index(index, 'my-ws', [plan])
+    assert changed is True
+    assert len(index['my-ws']) == 1
+    assert index['my-ws'][0]['path'] == 'a.md'
+
+
+def test_update_status_change(tmp_path: Path):
+    index = {
+        'my-ws': [
+            {'repo': 'r', 'path': 'a.md', 'title': 'A', 'status': 'active', 'created': '2026-01-01'},
+        ],
+    }
+    plan = PlanRef(repo='r', path='a.md', status='implemented', title='A', date='2026-01-01')
+    changed = update_plan_index(index, 'my-ws', [plan])
+    assert changed is True
+    assert index['my-ws'][0]['status'] == 'implemented'
+
+
+def test_update_no_change(tmp_path: Path):
+    index = {
+        'my-ws': [
+            {'repo': 'r', 'path': 'a.md', 'title': 'A', 'status': 'active', 'created': '2026-01-01'},
+        ],
+    }
+    plan = PlanRef(repo='r', path='a.md', status='active', title='A', date='2026-01-01')
+    changed = update_plan_index(index, 'my-ws', [plan])
+    assert changed is False
+
+
+def test_update_never_removes(tmp_path: Path):
+    index = {
+        'my-ws': [
+            {'repo': 'r', 'path': 'old.md', 'title': 'Old', 'status': 'implemented', 'created': '2025-01-01'},
+        ],
+    }
+    # Update with a different plan — old one must survive
+    plan = PlanRef(repo='r', path='new.md', status='active', title='New', date='2026-01-01')
+    update_plan_index(index, 'my-ws', [plan])
+    paths = [e['path'] for e in index['my-ws']]
+    assert 'old.md' in paths
+    assert 'new.md' in paths
+
+
+def test_update_backfills_title(tmp_path: Path):
+    index = {
+        'my-ws': [
+            {'repo': 'r', 'path': 'a.md', 'title': '', 'status': 'active', 'created': '2026-01-01'},
+        ],
+    }
+    plan = PlanRef(repo='r', path='a.md', status='active', title='Now Has Title', date='2026-01-01')
+    changed = update_plan_index(index, 'my-ws', [plan])
+    assert changed is True
+    assert index['my-ws'][0]['title'] == 'Now Has Title'

workstream/test/test_provisioning.py

@@ -0,0 +1,270 @@
+"""Tests for workstream.provisioning and workstream.commands.setup."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from workstream.provisioning import (
+    SetupResult,
+    _backup_if_modified,
+    deploy_extension,
+    deploy_skills,
+    setup_repo,
+)
+
+
+# ── _backup_if_modified ──────────────────────────────────────────────────
+
+
+def test_backup_noop_when_identical(tmp_path: Path) -> None:
+    """No backup when file matches reference."""
+    ref = tmp_path / "source.ts"
+    ref.write_text("content")
+    target = tmp_path / "dest.ts"
+    target.write_text("content")
+
+    msg = _backup_if_modified(target, reference=ref)
+    assert msg is None
+    # No .bak file created
+    assert not list(tmp_path.glob("*.bak"))
+
+
+def test_backup_when_modified(tmp_path: Path) -> None:
+    """Backup created when file differs from reference."""
+    ref = tmp_path / "source.ts"
+    ref.write_text("new content")
+    target = tmp_path / "dest.ts"
+    target.write_text("old content with local edits")
+
+    msg = _backup_if_modified(target, reference=ref)
+    assert msg is not None
+    assert "backed up" in msg
+
+    bak_files = list(tmp_path.glob("*.bak"))
+    assert len(bak_files) == 1
+    assert bak_files[0].read_text() == "old content with local edits"
+
+
+def test_backup_without_reference(tmp_path: Path) -> None:
+    """Backup created when no reference (file being removed)."""
+    target = tmp_path / "legacy.ts"
+    target.write_text("legacy content")
+
+    msg = _backup_if_modified(target)
+    assert msg is not None
+
+    bak_files = list(tmp_path.glob("*.bak"))
+    assert len(bak_files) == 1
+    assert bak_files[0].read_text() == "legacy content"
+
+
+def test_backup_nonexistent_file(tmp_path: Path) -> None:
+    """No backup when target doesn't exist."""
+    target = tmp_path / "missing.ts"
+    msg = _backup_if_modified(target)
+    assert msg is None
+
+
+# ── deploy_extension ─────────────────────────────────────────────────────
+
+
+def test_deploy_extension_creates_dir_and_copies(tmp_path: Path) -> None:
+    repo = tmp_path / "myrepo"
+    repo.mkdir()
+    msgs = deploy_extension(repo, harnesses=["omp"])
+    ext_path = repo / ".omp" / "extensions" / "workstream.ts"
+    assert ext_path.is_file()
+    assert any("deployed" in m for m in msgs)
+
+
+def test_deploy_extension_removes_legacy(tmp_path: Path) -> None:
+    repo = tmp_path / "myrepo"
+    ext_dir = repo / ".omp" / "extensions"
+    ext_dir.mkdir(parents=True)
+    (ext_dir / "plan-persist.ts").write_text("old")
+    (ext_dir / "workstream-persist.ts").write_text("old")
+
+    msgs = deploy_extension(repo, harnesses=["omp"])
+
+    assert not (ext_dir / "plan-persist.ts").exists()
+    assert not (ext_dir / "workstream-persist.ts").exists()
+    assert (ext_dir / "workstream.ts").is_file()
+    assert any("removed legacy plan-persist.ts" in m for m in msgs)
+    assert any("removed legacy workstream-persist.ts" in m for m in msgs)
+
+
+def test_deploy_extension_backs_up_modified_legacy(tmp_path: Path) -> None:
+    repo = tmp_path / "myrepo"
+    ext_dir = repo / ".omp" / "extensions"
+    ext_dir.mkdir(parents=True)
+    (ext_dir / "plan-persist.ts").write_text("locally edited legacy")
+
+    msgs = deploy_extension(repo, harnesses=["omp"])
+
+    # Legacy removed, backup created
+    assert not (ext_dir / "plan-persist.ts").exists()
+    bak_files = list(ext_dir.glob("plan-persist.ts.*.bak"))
+    assert len(bak_files) == 1
+    assert bak_files[0].read_text() == "locally edited legacy"
+    assert any("backed up" in m for m in msgs)
+
+
+def test_deploy_extension_backs_up_modified_current(tmp_path: Path) -> None:
+    repo = tmp_path / "myrepo"
+    ext_dir = repo / ".omp" / "extensions"
+    ext_dir.mkdir(parents=True)
+    (ext_dir / "workstream.ts").write_text("user modified this")
+
+    msgs = deploy_extension(repo, harnesses=["omp"])
+
+    # Current extension overwritten, backup created
+    assert (ext_dir / "workstream.ts").is_file()
+    assert (ext_dir / "workstream.ts").read_text() != "user modified this"
+    bak_files = list(ext_dir.glob("workstream.ts.*.bak"))
+    assert len(bak_files) == 1
+    assert bak_files[0].read_text() == "user modified this"
+    assert any("backed up" in m for m in msgs)
+
+
+def test_deploy_extension_no_backup_when_identical(tmp_path: Path) -> None:
+    """Re-deploying the same content doesn't create a backup."""
+    repo = tmp_path / "myrepo"
+    ext_dir = repo / ".omp" / "extensions"
+    ext_dir.mkdir(parents=True)
+
+    # First deploy
+    deploy_extension(repo, harnesses=["omp"])
+    # Second deploy — should not back up
+    msgs = deploy_extension(repo, harnesses=["omp"])
+
+    bak_files = list(ext_dir.glob("*.bak"))
+    assert len(bak_files) == 0
+    assert not any("backed up" in m for m in msgs)
+
+
+# ── deploy_skills ────────────────────────────────────────────────────────
+
+
+def test_deploy_skills_installs_all(tmp_path: Path) -> None:
+    repo = tmp_path / "myrepo"
+    repo.mkdir()
+    msgs = deploy_skills(repo, harnesses=["omp"])
+    skill_base = repo / ".omp" / "skills"
+    assert (skill_base / "workstream_context" / "SKILL.md").is_file()
+    # Session skills are NOT installed by deploy_skills
+    assert not (skill_base / "workstream_review" / "SKILL.md").exists()
+    assert not (skill_base / "workstream_init" / "SKILL.md").exists()
+    assert not (skill_base / "workstream_sweep" / "SKILL.md").exists()
+    assert any("installed skills" in m for m in msgs)
+
+
+def test_deploy_skills_preserves_existing(tmp_path: Path) -> None:
+    repo = tmp_path / "myrepo"
+    skill_base = repo / ".omp" / "skills"
+    custom_skill = skill_base / "my-custom-skill"
+    custom_skill.mkdir(parents=True)
+    (custom_skill / "SKILL.md").write_text("custom content")
+
+    deploy_skills(repo, harnesses=["omp"])
+
+    # Custom skill untouched
+    assert (custom_skill / "SKILL.md").read_text() == "custom content"
+    # Stub skill also installed
+    assert (skill_base / "workstream_context" / "SKILL.md").is_file()
+
+
+def test_deploy_skills_version_stamp(tmp_path: Path) -> None:
+    """Installed skill file has a version stamp appended."""
+    repo = tmp_path / "myrepo"
+    repo.mkdir()
+    deploy_skills(repo, harnesses=["omp"])
+    installed = (repo / ".omp" / "skills" / "workstream_context" / "SKILL.md").read_text()
+    assert "<!-- ws-installed-version:" in installed
+
+
+def test_deploy_skills_skips_when_current(tmp_path: Path) -> None:
+    """Second deploy returns 'up to date' when version matches."""
+    repo = tmp_path / "myrepo"
+    repo.mkdir()
+    deploy_skills(repo, harnesses=["omp"])
+    msgs = deploy_skills(repo, harnesses=["omp"])
+    assert any("up to date" in m for m in msgs)
+
+
+def test_deploy_skills_removes_legacy(tmp_path: Path) -> None:
+    """Legacy session skill dirs are cleaned up during deploy."""
+    repo = tmp_path / "myrepo"
+    skill_base = repo / ".omp" / "skills"
+    legacy_names = ["workstream_review", "workstream_init", "workstream_sweep", "workstream_focus"]
+    for name in legacy_names:
+        d = skill_base / name
+        d.mkdir(parents=True)
+        (d / "SKILL.md").write_text("old")
+
+    msgs = deploy_skills(repo, harnesses=["omp"])
+
+    for name in legacy_names:
+        assert not (skill_base / name).exists(), f"legacy {name} should be removed"
+    assert (skill_base / "workstream_context" / "SKILL.md").is_file()
+    assert any("removed legacy" in m for m in msgs)
+
+
+# ── setup_repo ───────────────────────────────────────────────────────────
+
+
+def test_setup_repo_returns_result(tmp_path: Path) -> None:
+    repo = tmp_path / "myrepo"
+    repo.mkdir()
+    result = setup_repo(repo, harnesses=["omp"])
+    assert isinstance(result, SetupResult)
+    assert len(result.extension_msgs) > 0
+    assert len(result.skill_msgs) > 0
+
+
+def test_setup_repo_idempotent(tmp_path: Path) -> None:
+    repo = tmp_path / "myrepo"
+    repo.mkdir()
+    setup_repo(repo, harnesses=["omp"])  # first run
+    r2 = setup_repo(repo, harnesses=["omp"])
+    # Both succeed, no backup on second run (content identical)
+    assert not any("backed up" in m for m in r2.extension_msgs)
+
+
+# ── _find_repo_root ──────────────────────────────────────────────────────
+
+
+
+
+def test_find_repo_root_by_path(tmp_path: Path) -> None:
+    from workstream.commands.setup import _find_repo_root
+    from workstream.config import Config
+
+    repo = tmp_path / "myrepo"
+    (repo / ".git").mkdir(parents=True)
+    config = Config()
+    result = _find_repo_root(str(repo), config)
+    assert result == repo
+
+
+def test_find_repo_root_by_name(tmp_path: Path) -> None:
+    from workstream.commands.setup import _find_repo_root
+    from workstream.config import Config, RepoConfig
+
+    repo = tmp_path / "myrepo"
+    (repo / ".git").mkdir(parents=True)
+    config = Config(repos=[RepoConfig(path=str(repo), name="myrepo")])
+    result = _find_repo_root("myrepo", config)
+    assert result == repo.resolve()
+
+
+def test_find_repo_root_not_found() -> None:
+    from face import CommandLineError
+
+    from workstream.commands.setup import _find_repo_root
+    from workstream.config import Config
+
+    config = Config()
+    with pytest.raises(CommandLineError, match="Cannot resolve"):
+        _find_repo_root("nonexistent-repo-xyz", config)