workstream-cli 0.0.1__py3-none-any.whl

workstream/test/test_sweep_state.py

@@ -0,0 +1,86 @@
+"""Tests for workstream.sweep_state — file change tracking for discovery sweeps."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from workstream.sweep_state import SweepState, load_sweep_state, save_sweep_state
+
+
+def test_sweep_state_empty(tmp_path: Path):
+    """Load from non-existent directory → empty state."""
+    state = load_sweep_state(tmp_path / "nonexistent")
+    assert state.files == {}
+    assert state.last_sweep == ''
+
+
+def test_sweep_state_round_trip(tmp_path: Path):
+    """Create state, save, load → same data."""
+    # Create a real file to track
+    f = tmp_path / "notes.md"
+    f.write_text("hello", encoding="utf-8")
+
+    state = SweepState(last_sweep='2026-03-28')
+    state.mark_processed(f)
+    save_sweep_state(state, tmp_path)
+
+    loaded = load_sweep_state(tmp_path)
+    assert loaded.last_sweep == '2026-03-28'
+    assert str(f) in loaded.files
+    fs = loaded.files[str(f)]
+    assert fs.path == str(f)
+    assert fs.processed is True
+    assert fs.content_hash == state.files[str(f)].content_hash
+    assert fs.mtime == state.files[str(f)].mtime
+
+
+def test_is_changed_new_file(tmp_path: Path):
+    """New file not in state → is_changed = True."""
+    f = tmp_path / "new.md"
+    f.write_text("content", encoding="utf-8")
+
+    state = SweepState()
+    assert state.is_changed(f) is True
+
+
+def test_is_changed_unchanged_file(tmp_path: Path):
+    """Mark processed, check again → is_changed = False."""
+    f = tmp_path / "stable.md"
+    f.write_text("content", encoding="utf-8")
+
+    state = SweepState()
+    state.mark_processed(f)
+    assert state.is_changed(f) is False
+
+
+def test_is_changed_modified_file(tmp_path: Path):
+    """Mark processed, modify file, check → is_changed = True."""
+    import time
+
+    f = tmp_path / "changing.md"
+    f.write_text("original", encoding="utf-8")
+
+    state = SweepState()
+    state.mark_processed(f)
+
+    # Ensure mtime differs (filesystem resolution can be coarse)
+    time.sleep(0.05)
+    f.write_text("modified", encoding="utf-8")
+
+    assert state.is_changed(f) is True
+
+
+def test_unprocessed_files(tmp_path: Path):
+    """Mix of new and processed files → returns only new ones."""
+    old = tmp_path / "old.md"
+    old.write_text("already seen", encoding="utf-8")
+    new1 = tmp_path / "new1.md"
+    new1.write_text("fresh", encoding="utf-8")
+    new2 = tmp_path / "new2.md"
+    new2.write_text("also fresh", encoding="utf-8")
+
+    state = SweepState()
+    state.mark_processed(old)
+
+    result = state.unprocessed_files([old, new1, new2])
+    assert set(result) == {new1, new2}

workstream/test/test_thoughts.py

@@ -0,0 +1,516 @@
+"""Tests for workstream.thoughts — thought extraction, association, and dispatch."""
+
+from __future__ import annotations
+
+import json
+from datetime import date
+from pathlib import Path
+from textwrap import dedent
+
+import pytest
+
+from workstream.markdown import load_workstream, parse_frontmatter
+from workstream.models import ThreadEntry, Workstream
+from workstream.thoughts import (
+    Thought,
+    ThoughtDispatchResult,
+    build_association_prompt,
+    build_discovery_prompt,
+    dispatch_associations,
+    extract_thoughts_from_text,
+    parse_association_response,
+)
+
+
+# ── Extraction ───────────────────────────────────────────────────────
+
+SPRINT_NOTE = dedent("""\
+    ## 2026-03-26
+    - TODO
+      - Fix onboarding bug
+      - Review PR #42
+    - Thoughts
+      - Should we add confetti to the welcome screen?
+      - Time to rethink the API versioning strategy
+      - That agent knowledge sharing idea keeps coming up
+    - Done
+      - Deployed landing page
+
+    ## 2026-03-25
+    - TODO
+      - Ship feature X
+    - Thoughts
+      - Would upgrading this library fix my bug?
+    - Done
+      - Merged PR #40
+
+    ## 2026-03-24
+    - TODO
+      - Write tests
+    - Done
+      - Completed integration tests
+""")
+
+
+def test_extract_thoughts_basic():
+    """Extract thoughts from a multi-day sprint note."""
+    thoughts = extract_thoughts_from_text(SPRINT_NOTE)
+    assert len(thoughts) == 4
+
+    # Day 1: three thoughts
+    day1 = [t for t in thoughts if t.date == "2026-03-26"]
+    assert len(day1) == 3
+    assert day1[0].text == "Should we add confetti to the welcome screen?"
+    assert day1[1].text == "Time to rethink the API versioning strategy"
+    assert day1[2].text == "That agent knowledge sharing idea keeps coming up"
+
+    # Day 2: one thought
+    day2 = [t for t in thoughts if t.date == "2026-03-25"]
+    assert len(day2) == 1
+    assert day2[0].text == "Would upgrading this library fix my bug?"
+
+    # Day 3: no thoughts section
+    day3 = [t for t in thoughts if t.date == "2026-03-24"]
+    assert len(day3) == 0
+
+
+def test_extract_thoughts_no_thoughts_section():
+    """No thoughts section in the text — returns empty."""
+    text = dedent("""\
+        ## 2026-03-20
+        - TODO
+          - Do stuff
+        - Done
+          - Did stuff
+    """)
+    assert extract_thoughts_from_text(text) == []
+
+
+def test_extract_thoughts_empty_text():
+    """Empty text — returns empty."""
+    assert extract_thoughts_from_text("") == []
+
+
+def test_extract_thoughts_source_file():
+    """Source file is recorded on each thought."""
+    thoughts = extract_thoughts_from_text(SPRINT_NOTE, source_file="sprint_2026-03-23.md")
+    assert all(t.source_file == "sprint_2026-03-23.md" for t in thoughts)
+
+
+def test_thought_equality():
+    """Thoughts are equal if date and text match."""
+    a = Thought(date="2026-03-26", text="hello")
+    b = Thought(date="2026-03-26", text="hello")
+    c = Thought(date="2026-03-26", text="different")
+    assert a == b
+    assert a != c
+
+
+
+# ── LLM prompt ───────────────────────────────────────────────────────
+
+def test_build_association_prompt():
+    """Prompt includes workstream context and thought list."""
+    ws = Workstream(
+        id="2026-03-15-abc123",
+        title="API Redesign",
+        status="active",
+        thread=[ThreadEntry(date="2026-03-25", body="Working on auth.")],
+    )
+    thoughts = [
+        Thought(date="2026-03-26", text="Should add confetti"),
+        Thought(date="2026-03-26", text="Rethink API versioning"),
+    ]
+
+    prompt = build_association_prompt(thoughts, [ws])
+    assert "2026-03-15-abc123" in prompt
+    assert "API Redesign" in prompt
+    assert "Should add confetti" in prompt
+    assert "Rethink API versioning" in prompt
+    assert "JSON array" in prompt
+
+
+def test_build_association_prompt_no_workstreams():
+    """Prompt works even with no workstreams."""
+    thoughts = [Thought(date="2026-03-26", text="Random idea")]
+    prompt = build_association_prompt(thoughts, [])
+    assert "no workstreams exist yet" in prompt
+
+
+# ── Response parsing ─────────────────────────────────────────────────
+
+def test_parse_association_response_valid():
+    """Parse a well-formed JSON response."""
+    response = """[
+        {"thought": "Add confetti", "action": "match", "workstream_id": "ws-123", "title": ""},
+        {"thought": "New idea", "action": "new", "workstream_id": "", "title": "Confetti Feature"},
+        {"thought": "Unclear", "action": "inbox", "workstream_id": "", "title": ""}
+    ]"""
+    result = parse_association_response(response)
+    assert len(result) == 3
+    assert result[0]["action"] == "match"
+    assert result[0]["workstream_id"] == "ws-123"
+    assert result[1]["action"] == "new"
+    assert result[1]["title"] == "Confetti Feature"
+    assert result[2]["action"] == "inbox"
+
+
+def test_parse_association_response_with_code_fences():
+    """Parse response wrapped in markdown code fences."""
+    response = """```json
+    [{"thought": "hello", "action": "inbox", "workstream_id": "", "title": ""}]
+    ```"""
+    result = parse_association_response(response)
+    assert len(result) == 1
+    assert result[0]["thought"] == "hello"
+
+
+def test_parse_association_response_invalid_json():
+    """Invalid JSON returns empty list."""
+    assert parse_association_response("this is not json") == []
+
+
+def test_parse_association_response_invalid_action():
+    """Entries with invalid actions are filtered out."""
+    response = '[{"thought": "hi", "action": "destroy", "workstream_id": ""}]'
+    result = parse_association_response(response)
+    assert len(result) == 0
+
+
+def test_parse_association_response_missing_fields():
+    """Entries missing required fields are filtered out."""
+    response = '[{"thought": "hi"}, {"action": "inbox"}]'
+    result = parse_association_response(response)
+    assert len(result) == 0
+
+
+# ── Dispatch ─────────────────────────────────────────────────────────
+
+@pytest.fixture()
+def dispatch_env(tmp_path: Path):
+    """Set up a workstreams directory with one workstream file for dispatch tests."""
+    ws_dir = tmp_path / "workstreams"
+    ws_dir.mkdir()
+
+    ws_text = dedent("""\
+        ---
+        id: 2026-03-15-abc123
+        title: API Redesign
+        status: active
+        size: week
+        created: '2026-03-15'
+        updated: '2026-03-25'
+        ---
+
+        # API Redesign
+
+        ## Thread
+        ### 2026-03-25
+        Working on auth.
+
+        ## Next
+        - Finish migration
+    """)
+    ws_file = ws_dir / "2026-03-15-abc123-api-redesign.md"
+    ws_file.write_text(ws_text, encoding="utf-8")
+    ws = load_workstream(ws_file)
+
+    return {"ws_dir": ws_dir, "ws": ws, "ws_file": ws_file}
+
+
+def test_dispatch_match(dispatch_env):
+    """Matched thoughts are appended to the workstream's thread."""
+    ws_dir = dispatch_env["ws_dir"]
+    ws = dispatch_env["ws"]
+    ws_file = dispatch_env["ws_file"]
+
+    thoughts = [Thought(date="2026-03-26", text="Rethink API versioning")]
+    associations = [{
+        "thought": "Rethink API versioning",
+        "action": "match",
+        "workstream_id": "2026-03-15-abc123",
+        "title": "",
+    }]
+
+    result = dispatch_associations(associations, thoughts, [ws], ws_dir)
+    assert result.matched == 1
+    assert result.new_created == 0
+    assert result.inbox_count == 0
+
+    # Verify the workstream file was updated
+    updated_text = ws_file.read_text(encoding="utf-8")
+    # No prefix — thought text appears directly
+    assert "Rethink API versioning" in updated_text
+    assert "(from thoughts sweep)" not in updated_text
+    meta, _ = parse_frontmatter(updated_text)
+    assert meta["updated"] == date.today().isoformat()
+    # Activity dates should be set
+    assert meta["first_activity"] == "2026-03-26"
+    assert meta["last_activity"] == "2026-03-26"
+
+
+def test_dispatch_new(dispatch_env):
+    """'new' action creates a new workstream file."""
+    ws_dir = dispatch_env["ws_dir"]
+    ws = dispatch_env["ws"]
+
+    thoughts = [Thought(date="2026-03-26", text="Agent knowledge sharing")]
+    associations = [{
+        "thought": "Agent knowledge sharing",
+        "action": "new",
+        "workstream_id": "",
+        "title": "Agent Knowledge Sharing",
+    }]
+
+    result = dispatch_associations(associations, thoughts, [ws], ws_dir)
+    assert result.new_created == 1
+
+    # Find the new file
+    new_files = [f for f in ws_dir.glob("*.md") if "agent-knowledge-sharing" in f.name]
+    assert len(new_files) == 1
+    new_ws = load_workstream(new_files[0])
+    assert new_ws.title == "Agent Knowledge Sharing"
+    assert new_ws.status == "active"
+    assert len(new_ws.thread) == 1
+    assert new_ws.thread[0].body == "Agent knowledge sharing"
+    assert "(from thoughts sweep)" not in new_ws.thread[0].body
+    # Activity dates set to thought date
+    assert new_ws.first_activity == "2026-03-26"
+    assert new_ws.last_activity == "2026-03-26"
+
+def test_dispatch_inbox(dispatch_env):
+    """'inbox' action writes to inbox.md."""
+    ws_dir = dispatch_env["ws_dir"]
+    ws = dispatch_env["ws"]
+
+    thoughts = [Thought(date="2026-03-26", text="Something unclear")]
+    associations = [{
+        "thought": "Something unclear",
+        "action": "inbox",
+        "workstream_id": "",
+        "title": "",
+    }]
+
+    result = dispatch_associations(associations, thoughts, [ws], ws_dir)
+    assert result.inbox_count == 1
+
+    inbox = ws_dir / "inbox.md"
+    assert inbox.exists()
+    content = inbox.read_text(encoding="utf-8")
+    assert "Something unclear" in content
+    assert "2026-03-26" in content
+
+
+def test_dispatch_match_bad_id(dispatch_env):
+    """Match with invalid workstream ID falls through to inbox."""
+    ws_dir = dispatch_env["ws_dir"]
+    ws = dispatch_env["ws"]
+
+    thoughts = [Thought(date="2026-03-26", text="Mystery")]
+    associations = [{
+        "thought": "Mystery",
+        "action": "match",
+        "workstream_id": "nonexistent-id",
+        "title": "",
+    }]
+
+    result = dispatch_associations(associations, thoughts, [ws], ws_dir)
+    assert result.matched == 0
+    assert result.inbox_count == 1
+    assert len(result.errors) == 1
+
+
+def test_dispatch_new_with_parent(dispatch_env):
+    """'new' action with parent_id sets parent on the new workstream."""
+    ws_dir = dispatch_env["ws_dir"]
+    ws = dispatch_env["ws"]
+
+    thoughts = [Thought(date="2026-03-26", text="Auth migration plan")]
+    associations = [{
+        "thought": "Auth migration plan",
+        "action": "new",
+        "workstream_id": "",
+        "title": "Auth Migration",
+        "parent_id": "2026-03-15-abc123",  # existing ws ID
+    }]
+
+    result = dispatch_associations(associations, thoughts, [ws], ws_dir)
+    assert result.new_created == 1
+
+    new_files = [f for f in ws_dir.glob("*.md") if "auth-migration" in f.name]
+    assert len(new_files) == 1
+    new_ws = load_workstream(new_files[0])
+    assert new_ws.parent == "2026-03-15-abc123"
+
+
+def test_dispatch_new_with_invalid_parent(dispatch_env):
+    """'new' action with non-existent parent_id ignores the parent."""
+    ws_dir = dispatch_env["ws_dir"]
+    ws = dispatch_env["ws"]
+
+    thoughts = [Thought(date="2026-03-26", text="Random project")]
+    associations = [{
+        "thought": "Random project",
+        "action": "new",
+        "workstream_id": "",
+        "title": "Random Project",
+        "parent_id": "nonexistent-id",
+    }]
+
+    result = dispatch_associations(associations, thoughts, [ws], ws_dir)
+    assert result.new_created == 1
+
+    new_files = [f for f in ws_dir.glob("*.md") if "random-project" in f.name]
+    assert len(new_files) == 1
+    new_ws = load_workstream(new_files[0])
+    assert new_ws.parent == ""  # invalid parent_id was dropped
+
+
+# ── Snooze computation ────────────────────────────────────────────────
+
+
+def test_compute_snooze_tomorrow():
+    from datetime import date
+    from workstream.thoughts import compute_snooze_until
+    result_date, count = compute_snooze_until('tomorrow', 0, from_date=date(2026, 3, 28))
+    assert result_date == '2026-03-29'
+    assert count == 0
+
+
+def test_compute_snooze_next_week():
+    from datetime import date
+    from workstream.thoughts import compute_snooze_until
+    # 2026-03-28 is Saturday → next Monday is 2026-03-30
+    result_date, count = compute_snooze_until('next-week', 0, from_date=date(2026, 3, 28))
+    assert result_date == '2026-03-30'
+    assert count == 0
+
+
+def test_compute_snooze_later_escalation():
+    from datetime import date
+    from workstream.thoughts import compute_snooze_until
+    base = date(2026, 3, 28)
+    # 1st later: +1 week
+    d, c = compute_snooze_until('later', 0, from_date=base)
+    assert d == '2026-04-04'
+    assert c == 1
+    # 2nd later: +2 weeks
+    d, c = compute_snooze_until('later', 1, from_date=base)
+    assert d == '2026-04-11'
+    assert c == 2
+    # 3rd later: +1 month (30 days)
+    d, c = compute_snooze_until('later', 2, from_date=base)
+    assert d == '2026-04-27'
+    assert c == 3
+    # 6th+ later: +6 months (182 days) — caps at last schedule entry
+    d, c = compute_snooze_until('later', 10, from_date=base)
+    assert d == '2026-09-26'
+    assert c == 11
+
+
+def test_compute_snooze_next_month():
+    from datetime import date
+    from workstream.thoughts import compute_snooze_until
+    result_date, count = compute_snooze_until('next-month', 0, from_date=date(2026, 3, 28))
+    assert result_date == '2026-04-27'
+    assert count == 0
+
+
+def test_compute_snooze_invalid():
+    import pytest
+    from workstream.thoughts import compute_snooze_until
+    with pytest.raises(ValueError):
+        compute_snooze_until('invalid-duration')
+
+
+# ── Discovery prompt ───────────────────────────────────────────────
+
+
+def test_build_discovery_prompt_includes_workstream_context():
+    """Prompt includes workstream IDs, titles, and status."""
+    ws = Workstream(
+        id="2026-03-15-abc123",
+        title="API Redesign",
+        status="active",
+        thread=[ThreadEntry(date="2026-03-25", body="Working on auth.")],
+    )
+    prompt = build_discovery_prompt("some content", [ws], "sprint_2026-03-23.md")
+    assert "2026-03-15-abc123" in prompt
+    assert "API Redesign" in prompt
+    assert "[active]" in prompt
+    assert "sprint_2026-03-23.md" in prompt
+    assert "some content" in prompt
+
+
+def test_build_discovery_prompt_no_workstreams():
+    """Prompt works with no workstreams."""
+    prompt = build_discovery_prompt("content", [], "sprint_2026-03-01.md")
+    assert "no workstreams exist yet" in prompt
+    assert "sprint_2026-03-01.md" in prompt
+
+
+def test_build_discovery_prompt_instructions():
+    """Prompt includes extraction instructions and JSON format."""
+    prompt = build_discovery_prompt("content", [], "test.md")
+    # Key extraction instructions
+    assert "Thoughts" in prompt
+    assert "Do NOT extract" in prompt
+    assert "JSON array" in prompt
+    # Format spec
+    assert '"date"' in prompt
+    assert '"thought"' in prompt
+    assert '"action"' in prompt
+    assert '"workstream_id"' in prompt
+    assert '"title"' in prompt
+    assert '"parent_id"' in prompt
+    # Date range handling instruction
+    assert "through" in prompt
+
+
+def test_build_discovery_prompt_embeds_file_content():
+    """Full file content is embedded in the prompt."""
+    content = dedent("""\
+        ## 2026-03-09
+        - Thoughts
+        \t- Tab-indented thought here
+        - Launch thoughts
+          - This is a named thought section
+    """)
+    prompt = build_discovery_prompt(content, [], "sprint_2026-03-09.md")
+    assert "Tab-indented thought here" in prompt
+    assert "Launch thoughts" in prompt
+    assert "named thought section" in prompt
+
+
+def test_build_discovery_prompt_shows_hierarchy():
+    """Prompt shows parent→child nesting in the workstream tree."""
+    parent_ws = Workstream(
+        id="ws-parent",
+        title="FOSS",
+        status="active",
+    )
+    child_ws = Workstream(
+        id="ws-child",
+        title="boltons",
+        status="active",
+        parent="ws-parent",
+    )
+    prompt = build_discovery_prompt("content", [parent_ws, child_ws], "test.md")
+    # Child should be indented under parent
+    assert "- ws-parent | FOSS [active]" in prompt
+    assert "  - ws-child | boltons [active] (child of FOSS)" in prompt
+
+
+def test_build_discovery_prompt_with_repo_context():
+    """Prompt includes repo context when provided."""
+    prompt = build_discovery_prompt("content", [], "test.md", repo_context="some repo info")
+    assert "REPO ACTIVITY:" in prompt
+    assert "some repo info" in prompt
+
+
+def test_build_discovery_prompt_no_repo_context():
+    """Prompt omits repo section when no repo context."""
+    prompt = build_discovery_prompt("content", [], "test.md")
+    assert "REPO ACTIVITY:" not in prompt
+    prompt2 = build_discovery_prompt("content", [], "test.md", repo_context='')
+    assert "REPO ACTIVITY:" not in prompt2