workstream-cli 0.0.1__py3-none-any.whl

workstream/commands/focus_cmd.py

@@ -0,0 +1,273 @@
+"""ws focus -- set weekly priorities and identify blocked/agent-actionable items.
+
+Gathers deterministic context (active workstreams, blocked items, expiring
+snoozes, previous focus), writes a manifest, and execs into omp with the
+focus skill.  The skill drives the interactive session; the focus artifact
+captures decisions.
+
+Execution mode: handoff (direct -> omp exec).  Falls back to printing
+the manifest when already inside an agent session (tool mode).
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import tempfile
+from datetime import date, timedelta
+from pathlib import Path
+
+from face import Command
+
+from workstream.cli import load_all_workstreams
+from workstream.commands.init import _read_skill_content
+from workstream.config import Config
+from workstream.focus_artifact import (
+    FocusArtifact,
+    load_current_week_focus,
+    load_latest_focus,
+)
+from workstream.harness import exec_or_fallback, find_harness
+
+
+# ── Helpers ─────────────────────────────────────────────────────────
+
+
+def _parse_within(within: str | None) -> int | None:
+    """Parse a duration string like '2d' into days, or None for calendar week default."""
+    if within is None:
+        return None
+    m = re.fullmatch(r'(\d+)d', within.strip())
+    if not m:
+        raise ValueError(f'Invalid --within value {within!r}; expected e.g. "2d", "7d"')
+    return int(m.group(1))
+
+
+def _find_current_focus(
+    ws_dir: Path, within: str | None = None,
+) -> FocusArtifact | None:
+    """Find the most recent non-expired focus doc within the freshness window.
+
+    If *within* is provided (e.g. '3d'), looks back that many days.
+    Otherwise uses calendar-week semantics via load_current_week_focus.
+    """
+    days = _parse_within(within)
+    if days is not None:
+        # Custom window: find most recent focus doc within N days
+        focus_dir = ws_dir / 'focus'
+        if not focus_dir.is_dir():
+            return None
+        cutoff = (date.today() - timedelta(days=days)).isoformat()
+        today_str = date.today().isoformat()
+        files = sorted(focus_dir.glob('*.md'), reverse=True)
+        for f in files:
+            stem = f.stem  # YYYY-MM-DD
+            if stem < cutoff:
+                break  # sorted descending; no point continuing
+            from workstream.focus_artifact import load_focus
+
+            artifact = load_focus(f)
+            # Skip expired docs
+            if artifact.expires and artifact.expires < today_str:
+                continue
+            return artifact
+        return None
+    else:
+        return load_current_week_focus(ws_dir)
+
+
+# ── Manifest builder ────────────────────────────────────────────────
+
+
+def _build_focus_manifest(
+    config: Config,
+    ws_dir: Path,
+    existing: FocusArtifact | None,
+    previous: FocusArtifact | None,
+) -> str:
+    """Build a structured context manifest for the focus skill."""
+    today = date.today()
+    today_str = today.isoformat()
+    workstreams = load_all_workstreams(ws_dir)
+
+    active = [w for w in workstreams if w.status == 'active']
+    blocked = [w for w in workstreams if w.status == 'blocked']
+    stale = [w for w in active if w.days_idle() > 7]
+    directionless = [w for w in workstreams if w.needs_direction()]
+
+    # Expiring snoozes (within 48h)
+    cutoff_snooze = (today + timedelta(days=2)).isoformat()
+    expiring_snoozes = [
+        w for w in workstreams
+        if w.snooze_until and w.snooze_until <= cutoff_snooze and w.status == 'snoozed'
+    ]
+
+    lines: list[str] = [
+        '## Focus Session Context',
+        '',
+        f'Today: {today_str}',
+    ]
+
+    # Mode
+    if existing:
+        lines.append('Mode: Iterating on existing focus doc')
+    else:
+        lines.append('Mode: New focus session')
+    lines.append('')
+
+    # State summary
+    lines.append(
+        f'State: {len(active)} active, {len(blocked)} blocked, '
+        f'{len(stale)} stale, {len(directionless)} needs direction, '
+        f'{len(expiring_snoozes)} expiring snoozes'
+    )
+    lines.append('')
+
+    # ── Existing focus doc (iterating) ──────────────────────────────
+    if existing:
+        lines.append('### Current Focus Doc')
+        lines.append(f'Date: {existing.date}')
+        if existing.expires:
+            lines.append(f'Expires: {existing.expires}')
+        if existing.priorities:
+            lines.append('')
+            lines.append('**Priorities:**')
+            for p in existing.priorities:
+                reason = f' — {p["reason"]}' if p.get('reason') else ''
+                lines.append(f'- {p["id"]}{reason}')
+        if existing.blocked:
+            lines.append('')
+            lines.append('**Blocked:**')
+            for b in existing.blocked:
+                on = f' — {b["on"]}' if b.get('on') else ''
+                lines.append(f'- {b["id"]}{on}')
+        if existing.context:
+            lines.append('')
+            lines.append(f'**Context:** {existing.context}')
+        if existing.body:
+            lines.append('')
+            lines.append(existing.body)
+        lines.append('')
+
+    # ── Previous focus doc (new session, for continuity) ────────────
+    if previous and not existing:
+        lines.append('### Previous Focus Doc (for continuity)')
+        lines.append(f'Date: {previous.date}')
+        if previous.priorities:
+            lines.append('')
+            lines.append('**Priorities:**')
+            for p in previous.priorities:
+                reason = f' — {p["reason"]}' if p.get('reason') else ''
+                lines.append(f'- {p["id"]}{reason}')
+        if previous.body:
+            lines.append('')
+            body_preview = '\n'.join(previous.body.splitlines()[:20])
+            lines.append(body_preview)
+        lines.append('')
+
+    # ── Active workstreams overview ─────────────────────────────────
+    active.sort(key=lambda w: w.days_idle(), reverse=True)
+    lines.append(f'### Active Workstreams ({len(active)})')
+    for w in active:
+        summary = f' — {w.summary}' if w.summary else ''
+        idle_str = f'{w.days_idle()}d idle' if w.days_idle() > 0 else 'active today'
+        entry = w.last_thread_entry
+        last_entry = (
+            f', last: [{entry.date}] {entry.body.splitlines()[0][:60]}'
+            if entry else ''
+        )
+        lines.append(f'- **{w.title}** ({idle_str}{last_entry}{summary})')
+    lines.append('')
+
+    # ── Blocked workstreams ─────────────────────────────────────────
+    lines.append(f'### Blocked ({len(blocked)})')
+    if blocked:
+        for w in blocked:
+            summary = f' — {w.summary}' if w.summary else ''
+            lines.append(f'- **{w.title}**{summary}')
+    else:
+        lines.append('(none)')
+    lines.append('')
+
+    # ── Needs direction ─────────────────────────────────────────────
+    lines.append(f'### Needs Direction ({len(directionless)})')
+    if directionless:
+        for w in directionless:
+            lines.append(f'- **{w.title}** (no next actions, no active plans)')
+    else:
+        lines.append('(none)')
+    lines.append('')
+
+    # ── Expiring snoozes ────────────────────────────────────────────
+    lines.append(f'### Expiring Snoozes ({len(expiring_snoozes)})')
+    if expiring_snoozes:
+        expiring_snoozes.sort(key=lambda w: w.snooze_until)
+        for w in expiring_snoozes:
+            reason = f' — {w.snooze_reason}' if w.snooze_reason else ''
+            lines.append(f'- **{w.title}** (until {w.snooze_until}{reason})')
+    else:
+        lines.append('(none)')
+    lines.append('')
+
+    return '\n'.join(lines)
+
+
+# ── Command handler ─────────────────────────────────────────────────
+
+
+def _focus_handler(config: Config, new: bool = False, within: str | None = None) -> None:
+    ws_dir = config.workstreams_path
+
+    # 1. Find existing focus doc (unless --new forces fresh)
+    existing: FocusArtifact | None = None
+    previous: FocusArtifact | None = None
+    if not new:
+        existing = _find_current_focus(ws_dir, within=within)
+
+    # 2. If creating new, offer previous doc for continuity
+    if existing is None:
+        previous = load_latest_focus(ws_dir)
+
+    # 3. Build the context manifest
+    manifest = _build_focus_manifest(config, ws_dir, existing, previous)
+
+    # 4. Find harness
+    harness = find_harness()
+    if not harness:
+        print('No interactive harness (omp or claude) found on PATH.')
+        print('Printing focus manifest for manual use:')
+        print()
+        print(manifest)
+        return
+
+
+    notes_root = ws_dir.parent
+
+    # 5. Write manifest to temp file (with skill content prepended)
+    skill = _read_skill_content('workstream_focus')
+    full_prompt = skill + '\n\n---\n\n' + manifest
+    fd, tmp_name = tempfile.mkstemp(suffix='.md', prefix='ws-focus-')
+    os.close(fd)
+    tmp_path = Path(tmp_name)
+    tmp_path.write_text(full_prompt, encoding='utf-8')
+
+    # 6. Exec into harness (or print manifest if already in agent session)
+    cmd = [
+        harness,
+        '--append-system-prompt', f'@{tmp_path}',
+        'Begin the focus session. Read the manifest in your system prompt and follow the focus skill protocol.',
+    ]
+
+    exec_or_fallback(harness, cmd, tmp_name, cwd=notes_root)
+
+
+def get_command() -> Command:
+    cmd = Command(
+        _focus_handler,
+        name='focus',
+        doc='Set weekly priorities and identify blocked/agent-actionable items.',
+    )
+    cmd.add('--new', parse_as=True, doc='Force new focus doc (ignore existing this week)')
+    cmd.add('--within', parse_as=str, missing=None,
+            doc='Freshness window for existing doc (e.g. 2d); default: calendar week')
+    return cmd

workstream/commands/idea.py

@@ -0,0 +1,172 @@
+"""ws idea / ws ideas / ws promote — idea management commands."""
+
+from __future__ import annotations
+
+from datetime import datetime, date
+
+from face import Command, CommandLineError
+
+from workstream.cli import resolve_workstream, load_all_workstreams
+from workstream.config import Config
+from workstream.markdown import (
+    load_workstream,
+    parse_frontmatter,
+    write_frontmatter,
+    append_idea,
+    append_log_entry,
+    parse_ideas,
+    _render_idea_line,
+    save_workstream,
+    set_section,
+)
+from workstream.models import IdeaEntry, LogEntry, Workstream, generate_id
+
+
+def _idea_handler(posargs_: tuple, config: Config) -> None:
+    if len(posargs_) < 2:
+        raise CommandLineError('Usage: ws idea <parent-id> <text...>')
+
+    id_prefix = posargs_[0]
+    idea_text = ' '.join(posargs_[1:])
+    now_dt = datetime.now().isoformat(timespec='seconds')
+    today_date = datetime.now().strftime('%Y-%m-%d')
+
+    ws = resolve_workstream(config, id_prefix)
+    # Re-load fresh from disk.
+    ws = load_workstream(ws.source_path)
+
+    text = ws.source_path.read_text(encoding='utf-8')
+    meta, body = parse_frontmatter(text)
+
+    idea = IdeaEntry(date=today_date, text=idea_text)
+    body = append_idea(body, idea)
+    body = append_log_entry(body, LogEntry(date=today_date, event='idea-added', detail=idea_text))
+    meta['updated'] = now_dt
+    meta['last_activity'] = now_dt
+
+    ws.source_path.write_text(
+        write_frontmatter(meta, body).rstrip('\n') + '\n',
+        encoding='utf-8',
+    )
+    print(f"Added idea to '{ws.title}': {idea_text}")
+
+
+def _ideas_handler(config: Config, all: bool = False) -> None:
+    ws_dir = config.workstreams_path
+    workstreams = load_all_workstreams(ws_dir)
+
+    today_str = datetime.now().strftime('%Y-%m-%d')
+    found_any = False
+
+    for ws in workstreams:
+        if not ws.ideas:
+            continue
+
+        visible = []
+        for i, idea in enumerate(ws.ideas, 1):
+            # Skip future-snoozed ideas unless --all.
+            if not all and idea.snooze_until and idea.snooze_until > today_str:
+                continue
+            visible.append((i, idea))
+
+        if not visible:
+            continue
+
+        found_any = True
+        print(f'{ws.title}:')
+        for idx, idea in visible:
+            line = f'  {idx}. [{idea.date}] {idea.text}'
+            if idea.snooze_until:
+                line += f' (snoozed until {idea.snooze_until})'
+            print(line)
+
+    if not found_any:
+        print('No ideas found.')
+
+
+def _promote_handler(posargs_: tuple, config: Config) -> None:
+    if len(posargs_) < 2:
+        raise CommandLineError('Usage: ws promote <parent-id> <index>')
+
+    id_prefix = posargs_[0]
+    try:
+        index = int(posargs_[1])
+    except ValueError:
+        raise CommandLineError(f'Index must be a number, got: {posargs_[1]}')
+
+    now_dt = datetime.now().isoformat(timespec='seconds')
+    today_date = datetime.now().strftime('%Y-%m-%d')
+    ws = resolve_workstream(config, id_prefix)
+    # Re-load fresh from disk.
+    ws = load_workstream(ws.source_path)
+
+    text = ws.source_path.read_text(encoding='utf-8')
+    meta, body = parse_frontmatter(text)
+    ideas = parse_ideas(body)
+
+    if index < 1 or index > len(ideas):
+        raise CommandLineError(
+            f'Invalid idea index {index}. '
+            f'{ws.title} has {len(ideas)} idea(s).'
+        )
+
+    idea = ideas[index - 1]
+    # Remove the promoted idea and re-render the section.
+    remaining = [i for j, i in enumerate(ideas) if j != index - 1]
+    if remaining:
+        new_section = '\n'.join(_render_idea_line(i) for i in remaining)
+    else:
+        new_section = ''
+    body = set_section(body, 'Ideas', new_section)
+    body = append_log_entry(
+        body,
+        LogEntry(date=today_date, event='idea-promoted', detail=f'{idea.text} -> {ws.id}'),
+    )
+    meta['updated'] = now_dt
+    meta['last_activity'] = now_dt
+    ws.source_path.write_text(
+        write_frontmatter(meta, body).rstrip('\n') + '\n',
+        encoding='utf-8',
+    )
+
+    # Create the new sub-workstream.
+    new_ws = Workstream(
+        id=generate_id(),
+        title=idea.text[:80],
+        status='active',
+        size='day',
+        parent=ws.id,
+        created=today_date,
+        updated=today_date,
+        last_activity=today_date,
+    )
+    new_ws.log.append(LogEntry(
+        date=today_date, event='created',
+        detail=f'(promoted from idea on {ws.title})',
+    ))
+    ws_dir = config.workstreams_path
+    save_workstream(new_ws, ws_dir / new_ws.filename)
+    print(f'Promoted idea to workstream: {new_ws.filename}')
+
+
+def get_idea_command() -> Command:
+    return Command(
+        _idea_handler, name='idea',
+        doc='Add an idea to a workstream.', posargs=True,
+    )
+
+
+def get_ideas_command() -> Command:
+    cmd = Command(
+        _ideas_handler, name='ideas',
+        doc='List ideas across all workstreams.',
+    )
+    cmd.add('--all', parse_as=True, doc='Include snoozed ideas')
+    return cmd
+
+
+def get_promote_command() -> Command:
+    return Command(
+        _promote_handler, name='promote',
+        doc='Promote an idea to a sub-workstream.', posargs=True,
+    )

workstream/commands/index.py

@@ -0,0 +1,89 @@
+"""ws index — generate an index.md for the workstreams directory."""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+from face import Command
+
+from workstream.config import Config
+from workstream.cli import load_all_workstreams
+from workstream.models import STATUSES, Workstream
+from workstream.commands.tree import build_tree_lines
+
+
+def _build_index(workstreams: list[Workstream]) -> str:
+    """Build the index.md content from a list of workstreams."""
+    today = datetime.now().strftime('%Y-%m-%d')
+    lines: list[str] = [
+        '# Workstream Index',
+        '',
+        f'*Generated by `ws index` on {today}*',
+    ]
+
+    # Group by status, preserving STATUSES order
+    by_status: dict[str, list[Workstream]] = {}
+    for ws in workstreams:
+        by_status.setdefault(ws.status, []).append(ws)
+
+    for status in STATUSES:
+        group = by_status.get(status)
+        if not group:
+            continue
+
+        lines.append('')
+        lines.append(f'## {status.capitalize()}')
+
+        if status == 'snoozed':
+            lines.append('| ID | Title | Snooze Reason | Last Updated | Days Idle |')
+            lines.append('|----|-------|---------------|--------------|-----------|')
+            for ws in group:
+                idle = ws.days_idle()
+                lines.append(
+                    f'| {ws.id} | {ws.title} | {ws.snooze_reason} '
+                    f'| {ws.computed_last_activity} | {idle} |'
+                )
+        else:
+            lines.append('| ID | Title | Size | Tags | Last Updated | Days Idle |')
+            lines.append('|----|-------|------|------|--------------|-----------|')
+            for ws in group:
+                tags = ', '.join(ws.tags) if ws.tags else ''
+                idle = ws.days_idle()
+                lines.append(
+                    f'| {ws.id} | {ws.title} | {ws.size} '
+                    f'| {tags} | {ws.computed_last_activity} | {idle} |'
+                )
+
+
+    lines.append('')
+    lines.append('## Hierarchy')
+    lines.append('')
+    lines.append('```')
+    tree_lines = build_tree_lines(workstreams, show_all=True)
+    lines.extend(tree_lines)
+    lines.append('```')
+
+    lines.append('')
+    return '\n'.join(lines)
+
+def _index_handler(config: Config, html: bool = False) -> None:
+    ws_dir = config.workstreams_path
+    workstreams = load_all_workstreams(config.workstreams_path)
+
+    # Always generate markdown index
+    content = _build_index(workstreams)
+    index_path = ws_dir / 'index.md'
+    index_path.write_text(content, encoding='utf-8')
+    print(f'Wrote index.md ({len(workstreams)} workstreams)')
+
+    # Optionally generate HTML dashboard
+    if html:
+        from workstream.web import generate_dashboard_file
+        out_path = generate_dashboard_file(ws_dir, workstreams)
+        print(f'Wrote {out_path.name}')
+
+
+def get_command() -> Command:
+    cmd = Command(_index_handler, name='index', doc='Generate index (and optional HTML dashboard) for workstreams.')
+    cmd.add('--html', parse_as=True, doc='Also generate an HTML dashboard')
+    return cmd