loopflow 0.7.2__tar.gz → 0.8.2__tar.gz

loopflow-0.8.2/.claude/commands/ux-review.md

@@ -0,0 +1,75 @@
+---
+requires: screenshot(s) in area
+produces: roadmap/concerto/<date>-<direction>-<order>-<slug>.md
+interactive: true
+---
+
+Review screenshot(s) through the lens of the given direction (persona).
+
+## Usage
+
+```bash
+# Review all screenshots with a persona
+lf ux-review --direction conductor --area docs/screenshots/
+
+# Review specific screenshot
+lf ux-review --direction conductor --area docs/screenshots/concerto-main.png
+```
+
+## Process
+
+For each screenshot in the area:
+1. Read the screenshot
+2. Apply each question from the direction
+3. For each question that the UI fails to answer well, write a backlog item file
+
+## Output format
+
+For each issue found, write a backlog item file in `roadmap/<wave>/`:
+
+- Use `--wave` if provided; otherwise infer from the worktree name.
+- If no wave can be determined, default to `roadmap/concerto/`.
+- Filename: `<date>-<direction>-<order>-<slug>.md`
+  - `date`: `YYYYMMDD`
+  - `direction`: the persona name
+  - `order`: zero-padded sequence number for this run (01, 02, 03...) in the order found
+  - `slug`: kebab-case title
+- Keep one issue per file
+- Use the format below
+- After writing files, print an ordered list of filenames with their wave folder
+
+```markdown
+---
+status: todo
+phase: 1
+persona: <direction-name>
+screenshot: <screenshot-path>
+order: <order>
+---
+
+# <Title>
+
+<One-line problem statement>
+
+## Current
+<What exists now>
+
+## Problem
+<Why it fails the persona question>
+
+## Build
+<What to change>
+
+## Done when
+<Persona question that should pass>
+```
+
+## Guidelines
+
+- Be specific about what you see in the screenshot
+- Quote the exact persona question being failed
+- Propose concrete changes, not vague improvements
+- One issue per backlog item file
+- Keep items right-sized: 1–2 concrete improvements, not a grab bag
+- Order matters: use the sequence from this run so ingestion preserves priority
+- Skip questions the UI already handles well

loopflow-0.8.2/.claude/commands/ux-synthesize-concerto.md

@@ -0,0 +1,78 @@
+---
+requires: roadmap items in persona waves
+produces: roadmap/concerto/<date>-<order>-<slug>.md
+interactive: true
+---
+Synthesize persona wave roadmaps into a single ordered Concerto backlog.
+
+## Inputs
+
+Read all items from these wave folders (if present):
+- `roadmap/conductor/`
+- `roadmap/improviser/`
+- `roadmap/listener/`
+- `roadmap/product-designer/`
+- `roadmap/ceo/`
+
+## Goal
+
+Produce a single ordered set of backlog items in `roadmap/concerto/` that:
+- Deduplicates overlapping issues across personas
+- Preserves the most actionable framing
+- Prioritizes by user impact and clarity
+
+## Process
+
+1. Cluster related items across waves (same problem, different framing).
+2. Pick the strongest framing and concrete Build steps.
+3. Assign an overall order (01, 02, 03...) for the Concerto backlog.
+4. Write one file per item to `roadmap/concerto/`.
+
+## Output format
+
+Write files with:
+
+- Filename: `<date>-<order>-<slug>.md`
+- `date`: `YYYYMMDD`
+- `order`: zero-padded sequence number
+- `slug`: kebab-case title
+
+Frontmatter:
+
+```markdown
+---
+status: todo
+phase: 1
+persona: concerto
+order: <order>
+sources: [conductor, improviser, listener, product-designer, ceo]
+---
+```
+
+Body:
+
+```markdown
+# <Title>
+
+<One-line problem statement>
+
+## Current
+<What exists now>
+
+## Problem
+<Why it fails across personas>
+
+## Build
+<What to change>
+
+## Done when
+<Concrete success condition>
+```
+
+## Guidelines
+
+- One issue per file
+- Keep items right-sized (1–2 concrete improvements)
+- Use the clearest wording from the source waves
+- Prefer outcomes that help multiple personas at once
+- Print an ordered list of filenames at the end

loopflow-0.8.2/.github/workflows/ci.yml

@@ -0,0 +1,56 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  merge_group:
+
+jobs:
+  rust-test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Run cargo fmt check
+        run: cargo fmt --all -- --check
+      - name: Run cargo clippy
+        run: cargo clippy --all-targets -- -D warnings
+      - name: Run Rust tests
+        run: cargo test --all
+
+  python-test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v4
+      - name: Run Python tests
+        run: uv run pytest python/tests/
+
+  e2e-smoke:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Run E2E smoke test
+        run: tests/e2e/test_smoke.sh
+
+  swift-test:
+    runs-on: macos-15
+    steps:
+      - uses: actions/checkout@v4
+      - name: Run Swift tests
+        run: swift test --package-path swift
+
+  concerto-ui-test:
+    runs-on: macos-15
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install XcodeGen
+        run: brew install xcodegen
+      - name: Generate Xcode project
+        run: xcodegen generate
+        working-directory: swift
+      - name: Run Concerto UI tests
+        run: xcodebuild test -project LoopflowSwift.xcodeproj -scheme Concerto -destination 'platform=macOS'
+        working-directory: swift

loopflow-0.8.2/.github/workflows/clear-scratch.yml

@@ -0,0 +1,52 @@
+name: Clear Scratch
+
+on:
+  merge_group:
+    branches: [main]
+
+permissions:
+  contents: write
+
+jobs:
+  clear-scratch:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Clear scratch if needed
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          FILES=$(find scratch -type f ! -name '.gitkeep' 2>/dev/null || true)
+          if [ -z "$FILES" ]; then
+            echo "scratch/ is already clean"
+            exit 0
+          fi
+
+          echo "Clearing scratch/..."
+          echo "$FILES"
+
+          # Get the PR branch from merge group ref (format: gh-readonly-queue/main/pr-NUM-SHA)
+          PR_NUM=$(echo "${{ github.ref }}" | sed -n 's/.*pr-\([0-9]*\).*/\1/p')
+          PR_BRANCH=$(gh pr view "$PR_NUM" --json headRefName -q .headRefName)
+
+          echo "Pushing cleanup to PR branch: $PR_BRANCH"
+
+          # Checkout and clean the actual PR branch
+          git fetch origin "$PR_BRANCH"
+          git checkout "$PR_BRANCH"
+
+          find scratch -type f ! -name '.gitkeep' -delete
+          find scratch -type d -empty -delete 2>/dev/null || true
+          mkdir -p scratch
+          touch scratch/.gitkeep
+
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add scratch/
+          git commit -m "chore: clear scratch"
+          git push origin "$PR_BRANCH"
+
+          echo "Cleanup pushed - merge queue will restart with clean branch"

loopflow-0.8.2/.github/workflows/release.yml

@@ -0,0 +1,144 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  # Build native binaries (GitHub Releases, shell installer)
+  build-native:
+    strategy:
+      matrix:
+        include:
+          - os: macos-latest
+            target: aarch64-apple-darwin
+          - os: macos-15-intel
+            target: x86_64-apple-darwin
+          - os: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+          - os: ubuntu-24.04-arm
+            target: aarch64-unknown-linux-gnu
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set version from tag
+        run: sed -i.bak 's/^version = "0.0.0"/version = "'"${GITHUB_REF_NAME#v}"'"/' Cargo.toml && rm Cargo.toml.bak
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
+      - name: Build
+        run: cargo build --release --target ${{ matrix.target }} -p loopflow
+      - name: Package
+        run: |
+          cd target/${{ matrix.target }}/release
+          tar czf ../../../lf-${{ matrix.target }}.tar.gz lf lfd
+      - uses: actions/upload-artifact@v4
+        with:
+          name: native-${{ matrix.target }}
+          path: lf-*.tar.gz
+
+  # Publish to crates.io
+  publish-crates:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set version from tag
+        run: sed -i.bak 's/^version = "0.0.0"/version = "'"${GITHUB_REF_NAME#v}"'"/' Cargo.toml && rm Cargo.toml.bak
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Publish to crates.io
+        run: cargo publish -p loopflow --allow-dirty
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+
+  # Publish pure Python package to PyPI
+  publish-pypi:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: astral-sh/setup-uv@v4
+      - name: Build package
+        run: uv build
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/
+
+  # Create GitHub Release with native binaries
+  release:
+    needs: build-native
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: native-*
+          merge-multiple: true
+          path: dist/native
+      - name: Generate shell installer
+        run: |
+          cat > dist/install.sh << 'INSTALLER'
+          #!/bin/sh
+          set -eu
+
+          REPO="loopflowstudio/loopflow"
+          INSTALL_DIR="${LF_INSTALL_DIR:-$HOME/.local/bin}"
+
+          detect_target() {
+            os=$(uname -s)
+            arch=$(uname -m)
+            case "$os" in
+              Darwin)
+                case "$arch" in
+                  arm64|aarch64) echo "aarch64-apple-darwin" ;;
+                  x86_64) echo "x86_64-apple-darwin" ;;
+                  *) echo "Unsupported architecture: $arch" >&2; exit 1 ;;
+                esac ;;
+              Linux)
+                case "$arch" in
+                  aarch64) echo "aarch64-unknown-linux-gnu" ;;
+                  x86_64) echo "x86_64-unknown-linux-gnu" ;;
+                  *) echo "Unsupported architecture: $arch" >&2; exit 1 ;;
+                esac ;;
+              *) echo "Unsupported OS: $os" >&2; exit 1 ;;
+            esac
+          }
+
+          main() {
+            target=$(detect_target)
+            version="${1:-latest}"
+
+            if [ "$version" = "latest" ]; then
+              url="https://github.com/$REPO/releases/latest/download/lf-$target.tar.gz"
+            else
+              url="https://github.com/$REPO/releases/download/v$version/lf-$target.tar.gz"
+            fi
+
+            echo "Installing lf ($target)..."
+            mkdir -p "$INSTALL_DIR"
+            curl -fsSL "$url" | tar xz -C "$INSTALL_DIR"
+            chmod +x "$INSTALL_DIR/lf" "$INSTALL_DIR/lfd"
+            echo "Installed to $INSTALL_DIR/lf"
+
+            case ":$PATH:" in
+              *":$INSTALL_DIR:"*) ;;
+              *) echo "Add to PATH: export PATH=\"$INSTALL_DIR:\$PATH\"" ;;
+            esac
+          }
+
+          main "$@"
+          INSTALLER
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          generate_release_notes: true
+          files: |
+            dist/native/*.tar.gz
+            dist/install.sh

{loopflow-0.7.2 → loopflow-0.8.2}/.gitignore

@@ -7,13 +7,16 @@ __pycache__/
 xcuserdata/
 .swiftpm/xcode/
 swift/*.xcodeproj/
+dist/
 swift/dist/
 
 # Claude Code (personal state)
 .claude/settings.local.json
 
-# Loopflow (generated cache)
+# Loopflow (generated)
+.lf/log/
 .lf/summaries/
 *.profraw
+*.actual.md
 .DS_Store
 target/

loopflow-0.8.2/.lf/SUMMARIZE.md

@@ -0,0 +1,33 @@
+Create a reference summary of this content for LLM context.
+
+**OUTPUT BUDGET:** ~{token_budget} tokens. Use most of it—this is a budget to spend, not a limit to avoid.
+
+## What to Include
+
+**For code:**
+- Data structures with full type annotations
+- Public function signatures AND their docstrings (include the docstring text)
+- Key constants, enums, and configuration schemas
+- Entry points and CLI commands with usage examples
+
+**For documentation:**
+- Key concepts and definitions
+- Commands, APIs, and their usage examples
+- Configuration options and their effects
+
+**Style:**
+- Quote directly rather than paraphrase when the original is clear
+- Consolidate related definitions together
+- Preserve exact names, paths, commands, and terminology
+- Code blocks for anything that looks like code
+- Dense markdown, organized by topic/module
+
+**Priority when budget is tight:**
+1. Type definitions and schemas
+2. Public APIs with docstrings
+3. CLI usage examples
+4. Implementation patterns
+
+<source>
+{content}
+</source>

loopflow-0.8.2/.lf/config.yaml

@@ -0,0 +1,23 @@
+agent_model: claude:opus 
+yolo: true 
+chrome: true
+
+skill_sources:
+  - name: superpowers
+    prefix: sp
+    path: ~/.superpowers
+exclude:
+  - uv.lock
+push: true
+
+summary_tokens: 25000
+
+summaries:
+  - path: .
+    model: claude:sonnet
+
+branch_names:
+  schema: "{user}.{name}.{ts}"
+
+internal:
+  use_rust: true

loopflow-0.8.2/.lf/directions/conductor.md

@@ -0,0 +1,13 @@
+Managing multiple parallel workstreams. Checking in, not diving deep.
+
+- Can I see what needs attention without drilling in?
+- Is urgency visually obvious?
+- How many clicks from "I see a problem" to "I'm acting on it"?
+- Would I trust this to surface the right thing while I'm away?
+- Do routine actions feel like single actions or workflows?
+- Am I confirming things I already decided?
+
+Red flags:
+- Flat lists with no hierarchy
+- Status requires interaction to reveal
+- Confirmation dialogs for routine operations

loopflow-0.8.2/.lf/directions/improviser.md

@@ -0,0 +1,13 @@
+Exploring unfamiliar territory. Doesn't know the right approach yet.
+
+- How fast from intent to action?
+- Am I configuring things I don't care about yet?
+- Can I do one thing without committing to a sequence?
+- Does this feel like a workshop or a form?
+- If I change my mind, is that cheap?
+- Am I exploring or filling out paperwork?
+
+Red flags:
+- Setup wizards before first action
+- Required fields for optional concepts
+- Changing course requires starting over

loopflow-0.8.2/.lf/directions/listener.md

@@ -0,0 +1,13 @@
+Checking in, not coding. Needs to understand what happened and what matters next.
+
+- Can I tell what happened while I was gone?
+- Is "needs me" vs "fine" instant to distinguish?
+- Do I have to click into each item to understand state?
+- Is there a summary or must I reconstruct context?
+- Can I triage N items in a few minutes without opening details?
+
+Red flags:
+- No history/timeline visible
+- State only visible after navigation
+- No clear explanation of why something is blocked
+- Requires taking action before understanding