codeloop 0.1.4 → 0.1.7

package/dist/templates/cursor-rules.js

@@ -40,126 +40,76 @@ If the project has a UI (Flutter, web app, mobile app, desktop app):
 ### Step B: Video capture review (dynamic correctness)
 After screenshots pass, record yourself OPERATING the app to catch transition,
 animation, and real-world UX issues that static screenshots miss:
-1. Identify 2-3 core user journeys (e.g., onboarding, main workflow, settings)
-2. Build and launch the app (if not already running)
-3. Call codeloop_start_recording with app_name — this brings the app to front and
+1. Build and launch the app (if not already running)
+2. Call codeloop_start_recording with app_name — this brings the app to front and
    starts recording in the background. The app window is un-minimized automatically.
-4. While recording is active, you MUST interact with the app. Do NOT just let it sit idle.
-   The video must show real interactions, not a still image. Follow the platform guide below.
-5. Wait 1-2 seconds between each interaction so frames capture each state change.
-6. Call codeloop_stop_recording — this finalizes the video and restores the IDE to the front.
-7. Call codeloop_interaction_replay with the run_id and expected_flow description
-8. Analyze the returned frame sequence for: broken transitions, stuck loading states,
+3. While recording is active, use codeloop_interact to interact with EVERY element in the app.
+   Do NOT use raw osascript/PowerShell/xdotool — use codeloop_interact for all interactions.
+   The video MUST show real interactions, not a still image. You must:
+   - Navigate to EVERY page/route in the app
+   - Click EVERY button, link, and navigation element
+   - Fill EVERY form field with test data and submit
+   - Open/close every modal, dropdown, menu, and accordion
+   - Test hover states, tooltips, and interactive components
+   - If auth screens exist: test login (test@example.com / TestPass123!), signup, change-password, logout
+   - Test form validation: submit empty forms, type invalid data, verify error messages
+   - Type+Save (edit → Cmd+S), Type+Submit (fill → Submit), Type+Search (query → Enter)
+   - Double-click, right-click, drag-and-drop, scroll every scrollable area
+   - Mobile: swipe, long-press, back button, deep links, permissions, rotate device
+4. Wait 1-2 seconds between each interaction so frames capture each state change.
+5. Call codeloop_stop_recording — this finalizes the video and restores the IDE to the front.
+6. Call codeloop_interaction_replay with the run_id and expected_flow description
+7. Analyze the returned frame sequence for: broken transitions, stuck loading states,
    window sizing issues, animation glitches, navigation dead-ends, and flow completion
-9. Fix any dynamic UX issues found
-10. ONLY THEN proceed to gate_check
+8. Fix any dynamic UX issues found
+9. ONLY THEN proceed to gate_check
 
 ### How to operate the app during recording:
 
-**Step 0: Identify the interaction types your app needs.**
-Read the source code to understand what interactions the app supports. Different
-apps require different interaction types. Choose from this list:
-
-| Interaction | When to use | macOS osascript | Playwright | Maestro |
-|-------------|-------------|----------------|------------|---------|
-| Click/tap | Buttons, links, menus, tabs | \`click at {x,y}\` | \`page.click(selector)\` | \`- tapOn: "label"\` |
-| Double-click | Select word, zoom, open item | \`double click at {x,y}\` | \`page.dblclick(selector)\` | \`- doubleTapOn\` |
-| Right-click | Context menus | \`click at {x,y} with command down\` | \`page.click(sel, {button:'right'})\` | N/A |
-| Type text | Input fields, search, forms | \`keystroke "hello"\` | \`page.fill(sel, "hello")\` | \`- inputText: "hello"\` |
-| Key press | Enter, Escape, Tab, shortcuts | \`key code 36\` (Return) | \`page.keyboard.press('Enter')\` | \`- pressKey: Enter\` |
-| Drag / draw | Drawing canvas, sliders, resize | \`click at {x1,y1}\` then \`click at {x2,y2}\` | \`page.mouse.move(); mouse.down(); mouse.move(); mouse.up()\` | \`- swipe\` |
-| Draw lines/curves | Ruler, design, annotation tools | Click multiple points with delays between | \`mouse.down()\` → series of \`mouse.move()\` → \`mouse.up()\` | Swipe gestures |
-| Scroll | Long pages, lists, content areas | \`scroll area 1 ... scroll down\` | \`page.mouse.wheel(0, 500)\` | \`- scroll\` |
-| Hover | Tooltips, dropdown menus | Move mouse without clicking | \`page.hover(selector)\` | N/A |
-| Long press | Mobile context actions | Hold click for 1+ seconds | \`page.click(sel, {delay: 1000})\` | \`- longPressOn\` |
-| Pinch/zoom | Maps, images, canvas | N/A (desktop) | N/A (browser) | \`- pinch\` |
-| Select from dropdown | Dropdown menus, pickers | Click dropdown → click option | \`page.selectOption(sel, val)\` | Tap to open → tap option |
-| Drag and drop | Sortable lists, kanban, file upload | Mouse down → move → mouse up | \`page.dragAndDrop(src, dst)\` | Swipe from → to |
-
-**Deciding which interactions to perform:**
-1. Read the app's source code: what features are implemented?
-   - A drawing app → test drawing lines, curves, shapes (click-drag sequences)
-   - A form-heavy app → test typing in fields, selecting dropdowns, submitting
-   - A navigation app → test clicking links, tabs, back buttons, breadcrumbs
-   - A canvas/ruler app → test clicking points, drawing measurements, using tools
-   - A dashboard → test clicking charts, filtering data, expanding panels
-2. Study the golden screenshots from Step A — what buttons, tools, and modes exist?
-3. Plan a realistic user journey that exercises the core features
-
-**Desktop apps (Flutter, native macOS/Windows/Linux):**
-Use OS-level automation. First study the golden screenshots and source code.
-
-*macOS:*
-- Click: \`osascript -e 'tell application "System Events" to click at {x, y}'\`
-- Drag/draw: click start point, wait, click end point (or series of points)
-- Type text: \`osascript -e 'tell application "System Events" to keystroke "text"'\`
-- Key press: \`osascript -e 'tell application "System Events" to key code 36'\` (Return=36, Escape=53, Tab=48)
-- Right-click: \`osascript -e 'tell application "System Events" to click at {x,y} with {control down}'\`
-
-*Windows:*
-Use PowerShell with user32.dll for automation:
-- Click: \`powershell -Command "Add-Type @'\\nusing System;using System.Runtime.InteropServices;\\npublic class W{[DllImport(\\"user32.dll\\")]public static extern bool SetCursorPos(int X,int Y);[DllImport(\\"user32.dll\\")]public static extern void mouse_event(uint f,int x,int y,uint d,UIntPtr e);}\\n'@; [W]::SetCursorPos(X,Y); [W]::mouse_event(0x0002,0,0,0,[UIntPtr]::Zero); Start-Sleep -Ms 50; [W]::mouse_event(0x0004,0,0,0,[UIntPtr]::Zero)"\`
-- Type text: \`powershell -Command "[System.Windows.Forms.SendKeys]::SendWait('text')"\`
-- Key press: \`powershell -Command "Add-Type @'\\nusing System;using System.Runtime.InteropServices;\\npublic class K{[DllImport(\\"user32.dll\\")]public static extern void keybd_event(byte k,byte s,uint f,UIntPtr e);}\\n'@; [K]::keybd_event(0x0D,0,0,[UIntPtr]::Zero); Start-Sleep -Ms 50; [K]::keybd_event(0x0D,0,2,[UIntPtr]::Zero)"\` (Enter=0x0D, Esc=0x1B, Tab=0x09)
-
-*Linux:*
-- Click: \`xdotool mousemove X Y click 1\`
-- Type text: \`xdotool type "text"\`
-- Key press: \`xdotool key Return\` (Return, Escape, Tab, space, etc.)
-- Drag: \`xdotool mousemove X1 Y1 mousedown 1 mousemove X2 Y2 mouseup 1\`
-
-All platforms: use codeloop_capture_screenshot between interactions to verify each action worked.
-
-**Web apps (React, Next.js, Vue, etc.):**
-Run Playwright test scripts that operate the real browser during recording:
-- \`npx playwright test --headed\` to run tests in a visible browser
-- Playwright handles clicks, typing, drag-and-drop, scrolling, hover — all captured in video
-- For drawing/canvas: use \`page.mouse.down()\`, \`page.mouse.move(x,y)\`, \`page.mouse.up()\`
-- Browser console logs are automatically captured by CodeLoop during recording
-
-**Mobile apps (iOS/Android):**
-
-*Android (emulator):*
-Use ADB commands or Maestro flows:
-- Tap: \`adb shell input tap X Y\`
-- Type: \`adb shell input text "hello"\`
-- Key press: \`adb shell input keyevent KEYCODE_ENTER\` (KEYCODE_BACK, KEYCODE_HOME, KEYCODE_TAB)
-- Swipe/scroll: \`adb shell input swipe X1 Y1 X2 Y2 300\`
-- Screenshot: \`adb shell screencap -p /sdcard/screen.png && adb pull /sdcard/screen.png\`
-- Start codeloop_start_recording with target_type="android_emulator" for device-level recording
-- App logs captured via \`adb logcat\` automatically during recording
-
-*iOS (simulator — macOS only):*
-Use Maestro or simctl:
-- Maestro flows: \`maestro test flows/\` — taps, swipes, long-press, pinch, scroll, text input
-- Launch app: \`xcrun simctl launch booted com.example.app\`
-- Terminate: \`xcrun simctl terminate booted com.example.app\`
-- Screenshot: \`xcrun simctl io booted screenshot output.png\`
-- Start codeloop_start_recording with target_type="ios_simulator" for simulator-level recording
-- App logs captured via \`simctl log stream\` automatically during recording
-
-*Android Studio native:*
-- Build: \`./gradlew assembleDebug\`
-- Test: \`./gradlew connectedAndroidTest\`
-- Interact via ADB commands as above
-
-*Xcode/Swift native (macOS only):*
-- Build: \`xcodebuild build -scheme AppName\`
-- Test: \`xcodebuild test -scheme AppName -destination 'platform=iOS Simulator,name=iPhone 16'\`
-- Interact via Maestro or XCUITest
-
-**Critical:** The video MUST show the app changing state — not a still image.
-Match the interaction types to what the app actually does. If the app is a drawing
-tool, the video must show drawing. If it's a form, the video must show typing and
-submitting. If you cannot automate a specific interaction, tell the user to operate
-the app manually while recording is active.
+Use the codeloop_interact tool for ALL interactions. Do NOT use raw osascript,
+PowerShell, xdotool, adb, or simctl commands directly. codeloop_interact
+handles all platforms automatically:
+
+**Available actions:** click, double_click, right_click, hover, type, keystroke,
+hotkey, scroll, drag_drop, long_press, type_and_submit, type_and_tab, fill_form,
+select_option, toggle, upload_file, navigate_url, navigate_back, wait, swipe,
+back_button, home_button, deep_link, grant_permission, rotate_device,
+biometric_auth, launch_app, clear_app_data, mock_location, simulate_network,
+maestro_flow, win_ui_inspect, win_ui_automate, sequence.
+
+**Examples:**
+- Click a button: \`codeloop_interact(action: "click", x: 200, y: 300)\`
+- Click browser element: \`codeloop_interact(action: "click", target_type: "browser", selector: "#submit-btn")\`
+- Type in field: \`codeloop_interact(action: "type", target_type: "browser", selector: "#email", text: "test@example.com")\`
+- Fill form + submit: \`codeloop_interact(action: "fill_form", target_type: "browser", fields: [{selector: "#email", value: "test@example.com"}, {selector: "#password", value: "TestPass123!"}], submit_selector: "#login-btn")\`
+- Scroll down: \`codeloop_interact(action: "scroll", direction: "down", amount: 300)\`
+- Press Enter: \`codeloop_interact(action: "keystroke", key: "enter")\`
+- Save with hotkey: \`codeloop_interact(action: "hotkey", keys: "cmd+s")\`
+- Type and search: \`codeloop_interact(action: "type_and_submit", selector: "#search", text: "query")\`
+- Android tap: \`codeloop_interact(action: "click", target_type: "android_emulator", x: 540, y: 960)\`
+- Android swipe: \`codeloop_interact(action: "swipe", target_type: "android_emulator", x: 540, y: 1200, x2: 540, y2: 600)\`
+- iOS deep link: \`codeloop_interact(action: "deep_link", target_type: "ios_simulator", url: "myapp://profile")\`
+- Maestro flow: \`codeloop_interact(action: "maestro_flow", maestro_steps: ["tap on \\"Login\\"", "type \\"hello\\"", "tap on \\"Submit\\""])\`
+
+**Mandatory interaction depth during recording:**
+- Navigate to EVERY page/route
+- Click EVERY button, link, nav element
+- Fill EVERY form field with test data and submit
+- Test auth flows if present: login, signup, change-password, logout
+- Test form validation: empty submissions, invalid data, error messages
+- Test compound patterns: type+save, type+submit, type+search, copy+paste, undo+redo
+- Open/close every modal, dropdown, accordion, tooltip
+- Scroll to bottom of every scrollable area
+- Test double-click, right-click, hover, drag-and-drop if applicable
+- Mobile: swipe, long-press, back button, rotate device, deep links
 
 **App logs:** CodeLoop automatically captures app runtime logs during video recording:
-- Flutter apps: \`flutter logs\` output
-- Android: \`adb logcat\` filtered to the app
-- iOS Simulator: \`simctl log stream\`
-- Native macOS: \`log stream --process\`
+- Flutter apps: flutter logs output
+- Android: adb logcat filtered to the app
+- iOS Simulator: simctl log stream
+- Native macOS: log stream --process
 - Web: browser console events via Playwright
+- Backend: dev server stdout/stderr
 These logs are included in the interaction_replay analysis so you can correlate
 visual frames with runtime errors, warnings, and exceptions.
 
@@ -172,13 +122,29 @@ Screenshots catch per-page layout issues. Video catches cross-page flow issues,
 transitions, animations, real window behavior, and interaction bugs that static
 screenshots miss entirely (e.g., wrong window size, broken navigation, stuck modals).
 
+## THE CODELOOP AUTO-FIX LOOP (MANDATORY)
+
+This is an AUTOMATIC loop. You do NOT ask the user for permission to continue.
+You do NOT stop and report partial progress. You keep going until the gate passes.
+
+Loop: Verify → Diagnose → Fix → Verify → ... → Screenshots → Video+Interact → Replay → Gate
+
+RULES:
+- If gate returns "continue_fixing": GO BACK TO codeloop_verify IMMEDIATELY.
+  Do NOT ask the user. Do NOT report partial results. Just fix and re-verify.
+- If gate returns "escalate": STOP and report blockers to the user.
+  Only escalate after 8 failed fix attempts OR a true blocker (missing dependency, etc.)
+- If gate returns "ready_for_review" with confidence >= 94%: proceed to dev report.
+- The user only sees the final result AFTER the gate passes at >= 94%.
+- Maximum loop iterations: 15. After 15 loops without reaching 94%, escalate.
+
 ## Before marking any task or feature as complete:
 1. Call codeloop_check_workflow to see which verification steps are still pending
 2. Complete ALL pending steps listed by codeloop_check_workflow
 3. Call codeloop_gate_check with the run_id, spec path, and acceptance path
-4. If the result says "continue_fixing", keep fixing and re-verifying
+4. If the result says "continue_fixing", LOOP BACK to codeloop_verify immediately — do NOT ask the user
 5. If the result says "escalate", stop and report the blockers to the developer
-6. Only declare the task complete when gate_check returns "ready_for_review" with confidence >= 85%
+6. Only declare the task complete when gate_check returns "ready_for_review" with confidence >= 94%
 7. Call codeloop_check_workflow one final time to confirm everything is done
 
 ## After the ENTIRE development loop is complete — MANDATORY development log:
@@ -245,15 +211,16 @@ Every CodeLoop-powered development session follows this mandatory lifecycle:
 1. **Implement** → write/modify code
 2. **Verify** → codeloop_verify (tests, lint, build)
 3. **Diagnose** → codeloop_diagnose (if failures)
-4. **Fix** → repair confirmed issues only
+4. **Fix** → repair confirmed issues only → LOOP BACK to step 2
 5. **Screenshot** → codeloop_capture_screenshot + codeloop_visual_review (all pages)
-6. **Video** → codeloop_start_recording → interact with ALL elements → codeloop_stop_recording
+6. **Video** → codeloop_start_recording → codeloop_interact with ALL elements → codeloop_stop_recording
 7. **Replay** → codeloop_interaction_replay (analyze frames + logs)
-8. **Gate** → codeloop_gate_check (confidence >= 85%)
+8. **Gate** → codeloop_gate_check (confidence >= 94%) — if "continue_fixing", LOOP to step 2 automatically
 9. **Report** → codeloop_generate_dev_report → write docs/DEVELOPMENT_LOG.md
 10. **Deliver** → present working project + development log to developer
 
 Steps 5-7 are MANDATORY for any project with a UI. Step 9 is MANDATORY for every project.
+The loop between steps 2-8 is AUTOMATIC. Do NOT ask the user between iterations.
 `;
 export const LOOP_MDC = `---
 description: CodeLoop multi-section development loop
@@ -269,7 +236,7 @@ When a master spec exists at docs/specs/_master.md:
 3. Read the spec file for the current section (the path is in the section_status response)
 4. Read the acceptance criteria file for the current section
 5. Implement the section according to the spec
-6. Run codeloop_verify → codeloop_diagnose → fix → repeat until codeloop_gate_check passes with confidence >= 85%
+6. Run codeloop_verify → codeloop_diagnose → fix → repeat until codeloop_gate_check passes with confidence >= 94%
 7. Call codeloop_section_status again to get the next section
 8. If more sections remain, proceed to the next section IMMEDIATELY
 9. Do NOT stop between sections for human review
@@ -283,7 +250,7 @@ When a master spec exists at docs/specs/_master.md:
 12. Only THEN report to the developer with the full evidence summary, confidence scores,
     and the development log — showing exactly how CodeLoop powered the quality assurance
 
-## After codeloop_gate_check returns "ready_for_review" with confidence >= 85%:
+## After codeloop_gate_check returns "ready_for_review" with confidence >= 94%:
 
 Generate or update the project README.md with:
 1. Project description and key features
@@ -549,31 +516,21 @@ For each page discovered, navigate to it and interact with these elements:
 - Verify sticky headers/footers remain visible
 - Check that lazy-loaded content appears when scrolled into view
 
-**How to interact — use osascript (macOS) or Playwright:**
-
-Navigate pages:
-\`osascript -e 'tell application "Google Chrome" to set URL of active tab of front window to "http://localhost:3000/page"'\`
-
-Click at coordinates (from screenshot analysis):
-\`osascript -e 'tell application "System Events" to click at {x, y}'\`
-
-Scroll down:
-\`osascript -e 'tell application "System Events" to key code 121'\`  (Page Down)
-
-Scroll to top:
-\`osascript -e 'tell application "System Events" to key code 115'\`  (Home)
-
-Type text in focused field:
-\`osascript -e 'tell application "System Events" to keystroke "test@example.com"'\`
-
-Press Enter:
-\`osascript -e 'tell application "System Events" to key code 36'\`
+**How to interact — use codeloop_interact:**
 
-Press Tab:
-\`osascript -e 'tell application "System Events" to key code 48'\`
+Use codeloop_interact with target_type="browser" for all web interactions:
+- Navigate: \`codeloop_interact(action: "navigate_url", target_type: "browser", url: "http://localhost:3000/page")\`
+- Click: \`codeloop_interact(action: "click", target_type: "browser", selector: "#btn")\`
+- Type: \`codeloop_interact(action: "type", target_type: "browser", selector: "#email", text: "test@example.com")\`
+- Fill form: \`codeloop_interact(action: "fill_form", target_type: "browser", fields: [...], submit_selector: "#submit")\`
+- Scroll: \`codeloop_interact(action: "scroll", target_type: "browser", direction: "down", amount: 500)\`
+- Select: \`codeloop_interact(action: "select_option", target_type: "browser", selector: "#dropdown", value: "option1")\`
+- Toggle: \`codeloop_interact(action: "toggle", target_type: "browser", selector: "#checkbox")\`
+- Hover: \`codeloop_interact(action: "hover", target_type: "browser", selector: ".tooltip-trigger")\`
+- Wait: \`codeloop_interact(action: "wait", duration_ms: 1500)\`
 
 **IMPORTANT:** Wait 1-2 seconds between each interaction so video frames capture
-each state change. Use \`await new Promise(r => setTimeout(r, 1500))\` in scripts.
+each state change.
 
 ### Step 4: Stop recording and analyze
 Call codeloop_stop_recording, then codeloop_interaction_replay with a detailed

package/dist/templates/cursor-rules.js.map

@@ -1 +1 @@
-{"version":3,"file":"cursor-rules.js","sourceRoot":"","sources":["../../src/templates/cursor-rules.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgQvB,CAAC;AAEF,MAAM,CAAC,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6CvB,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0FlC,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwC9B,CAAC;AAEF,MAAM,CAAC,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiC1B,CAAC;AAEF,MAAM,CAAC,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+HtB,CAAC;AAEF,MAAM,CAAC,MAAM,UAAU,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCzB,CAAC"}
+{"version":3,"file":"cursor-rules.js","sourceRoot":"","sources":["../../src/templates/cursor-rules.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+NvB,CAAC;AAEF,MAAM,CAAC,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6CvB,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0FlC,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwC9B,CAAC;AAEF,MAAM,CAAC,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiC1B,CAAC;AAEF,MAAM,CAAC,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqHtB,CAAC;AAEF,MAAM,CAAC,MAAM,UAAU,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCzB,CAAC"}

package/dist/templates/cursor-skills.d.ts

@@ -1,4 +1,4 @@
-export declare const SKILL_LOOP = "---\nname: codeloop-loop\ndescription: Run the full CodeLoop verify-diagnose-fix cycle until all quality gates pass. Use when implementing a feature end-to-end or completing a development section that requires verified, production-ready code.\n---\n\n# CodeLoop Loop\n\nOrchestrates the complete verification cycle for a feature or section.\n\n## When to use\n\n- After implementing a feature or completing a code change that needs verification\n- When working through a multi-section development plan\n- When you need evidence-based confirmation that code is ready for review\n\n## Instructions\n\n1. Call `codeloop_verify` with the appropriate scope (\"full\" for entire project, \"affected\" for changed files only) and platform (\"auto\" to detect, or \"flutter\"/\"web\"/\"mobile\" explicitly)\n\n2. Read the structured output. If all checks pass, proceed to step 5.\n\n3. If there are failures, call `codeloop_diagnose` with the `run_id` from the verify result. Read the categorized issues and repair tasks carefully.\n\n4. Fix ONLY the issues listed in the repair tasks. Do not guess or fix unrelated code. After fixing, go back to step 1 and re-verify. Repeat up to 8 times.\n\n5. Call `codeloop_gate_check` with the `run_id`, the spec path, and the acceptance criteria path.\n\n6. If gate_check returns:\n   - `\"ready_for_review\"` with confidence >= 85% \u2014 the task is complete\n   - `\"continue_fixing\"` \u2014 go back to step 1\n   - `\"escalate\"` \u2014 stop and report blockers to the developer\n\n7. If working through a multi-section plan, call `codeloop_section_status` to get the next section and repeat the entire cycle.\n\n## Important\n\n- Never mark a task complete without evidence from `codeloop_gate_check`\n- After 8 failed repair attempts, escalate instead of continuing\n- Trust deterministic results (test pass/fail) over model opinions\n";
+export declare const SKILL_LOOP = "---\nname: codeloop-loop\ndescription: Run the full CodeLoop verify-diagnose-fix cycle until all quality gates pass. Use when implementing a feature end-to-end or completing a development section that requires verified, production-ready code.\n---\n\n# CodeLoop Loop\n\nOrchestrates the complete verification cycle for a feature or section.\n\n## When to use\n\n- After implementing a feature or completing a code change that needs verification\n- When working through a multi-section development plan\n- When you need evidence-based confirmation that code is ready for review\n\n## Instructions\n\n1. Call `codeloop_verify` with the appropriate scope (\"full\" for entire project, \"affected\" for changed files only) and platform (\"auto\" to detect, or \"flutter\"/\"web\"/\"mobile\" explicitly)\n\n2. Read the structured output. If all checks pass, proceed to step 5.\n\n3. If there are failures, call `codeloop_diagnose` with the `run_id` from the verify result. Read the categorized issues and repair tasks carefully.\n\n4. Fix ONLY the issues listed in the repair tasks. Do not guess or fix unrelated code. After fixing, go back to step 1 and re-verify. Repeat up to 8 times.\n\n5. Call `codeloop_gate_check` with the `run_id`, the spec path, and the acceptance criteria path.\n\n6. If gate_check returns:\n   - `\"ready_for_review\"` with confidence >= 94% \u2014 the task is complete\n   - `\"continue_fixing\"` \u2014 go back to step 1\n   - `\"escalate\"` \u2014 stop and report blockers to the developer\n\n7. If working through a multi-section plan, call `codeloop_section_status` to get the next section and repeat the entire cycle.\n\n## Important\n\n- Never mark a task complete without evidence from `codeloop_gate_check`\n- After 8 failed repair attempts, escalate instead of continuing\n- Trust deterministic results (test pass/fail) over model opinions\n";
 export declare const SKILL_VERIFY = "---\nname: codeloop-verify\ndescription: Run a single CodeLoop verification pass to check if the current code compiles, passes tests, and meets quality standards. Use after any code change to get structured pass/fail results.\n---\n\n# CodeLoop Verify\n\nRuns a single verification pass and returns structured results.\n\n## When to use\n\n- After making code changes and wanting a quick check\n- Before committing code to ensure nothing is broken\n- When you need structured test/lint/build output instead of raw terminal output\n\n## Instructions\n\n1. Call `codeloop_verify` with parameters:\n   - `scope`: \"full\" (all checks) or \"affected\" (only changed files)\n   - `platform`: \"auto\" (detect from project), \"flutter\", \"web\", or \"mobile\"\n\n2. The tool returns a structured report containing:\n   - Pass/fail counts for each check category\n   - Artifact paths for logs and screenshots\n   - A next-step suggestion\n\n3. If there are failures, consider using the codeloop-loop skill for the full diagnose-fix cycle, or call `codeloop_diagnose` manually with the `run_id`.\n\n4. If all checks pass, you can proceed with confidence or run `codeloop_gate_check` for formal completion evidence.\n\n## Output format\n\nThe verification result includes:\n- `run_id`: unique identifier for this run (needed by diagnose and gate_check)\n- `summary`: overall pass/fail with counts\n- `checks`: detailed results per category (build, tests, lint, format)\n- `artifacts`: paths to generated logs and screenshots\n- `suggestion`: recommended next action\n";
 export declare const SKILL_VISUAL_REVIEW = "---\nname: codeloop-visual-review\ndescription: Capture screenshots of the current UI and analyze them for visual issues, layout problems, and design fidelity. Use after UI changes to catch visual regressions.\n---\n\n# CodeLoop Visual Review\n\nCaptures and analyzes UI screenshots for visual quality.\n\n## When to use\n\n- After making UI/styling changes and wanting to verify visual correctness\n- When a design reference image is available and you want to compare against it\n- When checking responsive layout across different viewport sizes\n- When verifying accessibility-related visual aspects (contrast, sizing)\n\n## Instructions\n\n### For visual review (no reference image):\n\n1. Call `codeloop_visual_review` with:\n   - `run_id`: from a recent `codeloop_verify` run (optional)\n   - `viewport_sizes`: array of viewport dimensions (e.g., [\"375x812\", \"1440x900\"])\n   - `ux_checklist_path`: path to UX checklist if one exists\n\n2. The tool captures screenshots at each viewport size and uses a vision model to identify issues.\n\n### For design comparison (with reference image):\n\n1. Call `codeloop_design_compare` with:\n   - `reference_image_path`: path to the design mockup or Figma export\n   - `screen_name`: identifier for the screen being compared\n   - `platform`: the platform being tested\n   - `viewport_sizes`: viewport dimensions to test\n\n2. The tool returns a match score, list of differences, and comparison screenshots.\n\n## Tips\n\n- Store design references in `artifacts/references/` for easy access\n- Run visual review after every UI change, not just at the end\n- Use the UX checklist template at `docs/ux-checklists/_template.md` for consistent checks\n";
 export declare const SKILL_RECOMMEND = "---\nname: codeloop-recommend\ndescription: Get evidence-based recommendations for third-party tools and services based on the project stack, budget, and constraints. Use when choosing hosting, databases, email services, analytics, or any infrastructure.\n---\n\n# CodeLoop Recommend\n\nProvides structured tool and service recommendations.\n\n## When to use\n\n- When the developer asks about hosting, deployment, or infrastructure options\n- When choosing between email services, analytics tools, auth providers, or databases\n- When evaluating tools for monitoring, file storage, or marketing\n- When the task requires selecting a third-party service and you want objective comparison\n\n## Instructions\n\n1. Call `codeloop_recommend_tool` with:\n   - `category`: the type of tool needed (e.g., \"hosting\", \"email\", \"database\", \"analytics\", \"auth\", \"monitoring\", \"file-storage\")\n   - `stack`: key-value pairs describing the current tech stack\n   - `budget`: \"free\", \"low\", \"medium\", or \"enterprise\"\n   - `constraints`: any specific requirements (e.g., `{\"gdpr\": true, \"region\": \"eu\"}`)\n\n2. The tool returns ranked recommendations with reasoning, pricing, tradeoffs, and starter tasks.\n\n3. Present the results with reasoning and tradeoffs \u2014 never just recommend a name without context.\n\n## Tips\n\n- Always include the current stack so recommendations account for compatibility\n- Set budget to match the developer's stated constraints\n- Use constraints for regulatory requirements (GDPR, SOC2, HIPAA)\n";

package/dist/templates/cursor-skills.js

@@ -26,7 +26,7 @@ Orchestrates the complete verification cycle for a feature or section.
 5. Call \`codeloop_gate_check\` with the \`run_id\`, the spec path, and the acceptance criteria path.
 
 6. If gate_check returns:
-   - \`"ready_for_review"\` with confidence >= 85% — the task is complete
+   - \`"ready_for_review"\` with confidence >= 94% — the task is complete
    - \`"continue_fixing"\` — go back to step 1
    - \`"escalate"\` — stop and report blockers to the developer
 

package/dist/templates/mcp-config.d.ts

@@ -20,5 +20,13 @@ export declare const CLAUDE_MCP_CONFIG: {
         };
     };
 };
+/**
+ * Returns MCP config with the actual API key value injected.
+ * When apiKey is provided, writes the real key instead of the env placeholder.
+ * This is critical for Claude Code which doesn't expand shell env vars in JSON.
+ */
+export declare function getMcpConfig(apiKey?: string | null): {
+    mcpServers: Record<string, unknown>;
+};
 export declare const CLAUDE_PERMISSIONS_ALLOW: string[];
 //# sourceMappingURL=mcp-config.d.ts.map

package/dist/templates/mcp-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-config.d.ts","sourceRoot":"","sources":["../../src/templates/mcp-config.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB;;;;;;;;;;CAU7B,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;CAU7B,CAAC;AAEF,eAAO,MAAM,wBAAwB,UA2BpC,CAAC"}
+{"version":3,"file":"mcp-config.d.ts","sourceRoot":"","sources":["../../src/templates/mcp-config.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB;;;;;;;;;;CAU7B,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;CAU7B,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAY5F;AAED,eAAO,MAAM,wBAAwB,UA2BpC,CAAC"}

package/dist/templates/mcp-config.js

@@ -20,6 +20,24 @@ export const CLAUDE_MCP_CONFIG = {
         },
     },
 };
+/**
+ * Returns MCP config with the actual API key value injected.
+ * When apiKey is provided, writes the real key instead of the env placeholder.
+ * This is critical for Claude Code which doesn't expand shell env vars in JSON.
+ */
+export function getMcpConfig(apiKey) {
+    return {
+        mcpServers: {
+            codeloop: {
+                command: "npx",
+                args: ["-y", "codeloop-mcp-server"],
+                env: {
+                    CODELOOP_API_KEY: apiKey || "${CODELOOP_API_KEY}",
+                },
+            },
+        },
+    };
+}
 export const CLAUDE_PERMISSIONS_ALLOW = [
     "Bash(flutter *)",
     "Bash(dart *)",

package/dist/templates/mcp-config.js.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-config.js","sourceRoot":"","sources":["../../src/templates/mcp-config.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,UAAU,EAAE;QACV,QAAQ,EAAE;YACR,OAAO,EAAE,KAAK;YACd,IAAI,EAAE,CAAC,IAAI,EAAE,qBAAqB,CAAC;YACnC,GAAG,EAAE;gBACH,gBAAgB,EAAE,qBAAqB;aACxC;SACF;KACF;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,UAAU,EAAE;QACV,QAAQ,EAAE;YACR,OAAO,EAAE,KAAK;YACd,IAAI,EAAE,CAAC,IAAI,EAAE,qBAAqB,CAAC;YACnC,GAAG,EAAE;gBACH,gBAAgB,EAAE,qBAAqB;aACxC;SACF;KACF;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,iBAAiB;IACjB,cAAc;IACd,aAAa;IACb,aAAa;IACb,cAAc;IACd,aAAa;IACb,cAAc;IACd,gBAAgB;IAChB,iBAAiB;IACjB,uBAAuB;IACvB,aAAa;IACb,eAAe;IACf,YAAY;IACZ,YAAY;IACZ,YAAY;IACZ,aAAa;IACb,YAAY;IACZ,eAAe;IACf,cAAc;IACd,cAAc;IACd,cAAc;IACd,cAAc;IACd,cAAc;IACd,YAAY;IACZ,cAAc;IACd,WAAW;CACZ,CAAC"}
+{"version":3,"file":"mcp-config.js","sourceRoot":"","sources":["../../src/templates/mcp-config.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,UAAU,EAAE;QACV,QAAQ,EAAE;YACR,OAAO,EAAE,KAAK;YACd,IAAI,EAAE,CAAC,IAAI,EAAE,qBAAqB,CAAC;YACnC,GAAG,EAAE;gBACH,gBAAgB,EAAE,qBAAqB;aACxC;SACF;KACF;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,UAAU,EAAE;QACV,QAAQ,EAAE;YACR,OAAO,EAAE,KAAK;YACd,IAAI,EAAE,CAAC,IAAI,EAAE,qBAAqB,CAAC;YACnC,GAAG,EAAE;gBACH,gBAAgB,EAAE,qBAAqB;aACxC;SACF;KACF;CACF,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,MAAsB;IACjD,OAAO;QACL,UAAU,EAAE;YACV,QAAQ,EAAE;gBACR,OAAO,EAAE,KAAK;gBACd,IAAI,EAAE,CAAC,IAAI,EAAE,qBAAqB,CAAC;gBACnC,GAAG,EAAE;oBACH,gBAAgB,EAAE,MAAM,IAAI,qBAAqB;iBAClD;aACF;SACF;KACF,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,iBAAiB;IACjB,cAAc;IACd,aAAa;IACb,aAAa;IACb,cAAc;IACd,aAAa;IACb,cAAc;IACd,gBAAgB;IAChB,iBAAiB;IACjB,uBAAuB;IACvB,aAAa;IACb,eAAe;IACf,YAAY;IACZ,YAAY;IACZ,YAAY;IACZ,aAAa;IACb,YAAY;IACZ,eAAe;IACf,cAAc;IACd,cAAc;IACd,cAAc;IACd,cAAc;IACd,cAAc;IACd,YAAY;IACZ,cAAc;IACd,WAAW;CACZ,CAAC"}

package/dist/utils/global-setup.d.ts

@@ -0,0 +1,2 @@
+export declare function applyGlobalMcpConfig(apiKey: string): Promise<void>;
+//# sourceMappingURL=global-setup.d.ts.map

package/dist/utils/global-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-setup.d.ts","sourceRoot":"","sources":["../../src/utils/global-setup.ts"],"names":[],"mappings":"AAMA,wBAAsB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAWxE"}

package/dist/utils/global-setup.js

@@ -0,0 +1,16 @@
+import { join } from "path";
+import { homedir } from "os";
+import { mergeMcpConfig } from "./file-writer.js";
+import { getMcpConfig } from "../templates/mcp-config.js";
+import { printSuccess } from "./ui.js";
+export async function applyGlobalMcpConfig(apiKey) {
+    const home = homedir();
+    const config = getMcpConfig(apiKey);
+    const cursorGlobalPath = join(home, ".cursor", "mcp.json");
+    mergeMcpConfig(cursorGlobalPath, config.mcpServers);
+    printSuccess("~/.cursor/mcp.json (global — all Cursor workspaces)");
+    const claudeGlobalPath = join(home, ".claude.json");
+    mergeMcpConfig(claudeGlobalPath, config.mcpServers);
+    printSuccess("~/.claude.json (global — all Claude Code workspaces)");
+}
+//# sourceMappingURL=global-setup.js.map

package/dist/utils/global-setup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-setup.js","sourceRoot":"","sources":["../../src/utils/global-setup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC5B,OAAO,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC;AAC7B,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC,MAAM,CAAC,KAAK,UAAU,oBAAoB,CAAC,MAAc;IACvD,MAAM,IAAI,GAAG,OAAO,EAAE,CAAC;IACvB,MAAM,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;IAEpC,MAAM,gBAAgB,GAAG,IAAI,CAAC,IAAI,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;IAC3D,cAAc,CAAC,gBAAgB,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC;IACpD,YAAY,CAAC,qDAAqD,CAAC,CAAC;IAEpE,MAAM,gBAAgB,GAAG,IAAI,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IACpD,cAAc,CAAC,gBAAgB,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC;IACpD,YAAY,CAAC,sDAAsD,CAAC,CAAC;AACvE,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeloop",
-  "version": "0.1.4",
+  "version": "0.1.7",
   "description": "CLI tool for CodeLoop — automated verification for AI coding agents",
   "type": "module",
   "bin": {
@@ -30,14 +30,15 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "commander": "^13.1.0",
     "@inquirer/prompts": "^7.5.0",
     "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "open": "^11.0.0",
     "ora": "^8.2.0"
   },
   "devDependencies": {
-    "typescript": "^5.8.3",
     "@types/node": "^22.15.3",
+    "typescript": "^5.8.3",
     "vitest": "^3.1.2"
   }
 }