Add files using upload-large-folder tool

projects/ui/crush/.github/CODEOWNERS

@@ -0,0 +1 @@
+*.go @charmbracelet/everyone

projects/ui/crush/.github/cla-signatures.json

@@ -0,0 +1,556 @@
+{
+  "signedContributors": [
+    {
+      "name": "caarlos0",
+      "id": 245435,
+      "comment_id": 3133376230,
+      "created_at": "2025-07-29T17:11:51Z",
+      "repoId": 987670088,
+      "pullRequestNo": 333
+    },
+    {
+      "name": "raphamorim",
+      "id": 3630346,
+      "comment_id": 3133374793,
+      "created_at": "2025-07-29T17:11:19Z",
+      "repoId": 987670088,
+      "pullRequestNo": 230
+    },
+    {
+      "name": "raphamorim",
+      "id": 3630346,
+      "comment_id": 3133379333,
+      "created_at": "2025-07-29T17:13:00Z",
+      "repoId": 987670088,
+      "pullRequestNo": 230
+    },
+    {
+      "name": "aymanbagabas",
+      "id": 3187948,
+      "comment_id": 3133374319,
+      "created_at": "2025-07-29T17:11:08Z",
+      "repoId": 987670088,
+      "pullRequestNo": 224
+    },
+    {
+      "name": "aymanbagabas",
+      "id": 3187948,
+      "comment_id": 3133398259,
+      "created_at": "2025-07-29T17:19:30Z",
+      "repoId": 987670088,
+      "pullRequestNo": 224
+    },
+    {
+      "name": "andreynering",
+      "id": 7011819,
+      "comment_id": 3133398174,
+      "created_at": "2025-07-29T17:19:29Z",
+      "repoId": 987670088,
+      "pullRequestNo": 323
+    },
+    {
+      "name": "ras0q",
+      "id": 66677201,
+      "comment_id": 3133486409,
+      "created_at": "2025-07-29T17:51:25Z",
+      "repoId": 987670088,
+      "pullRequestNo": 335
+    },
+    {
+      "name": "meowgorithm",
+      "id": 25087,
+      "comment_id": 3134117697,
+      "created_at": "2025-07-29T21:23:05Z",
+      "repoId": 987670088,
+      "pullRequestNo": 343
+    },
+    {
+      "name": "kujtimiihoxha",
+      "id": 14311743,
+      "comment_id": 3135739620,
+      "created_at": "2025-07-30T10:35:23Z",
+      "repoId": 987670088,
+      "pullRequestNo": 352
+    },
+    {
+      "name": "rio",
+      "id": 883894,
+      "comment_id": 3136448851,
+      "created_at": "2025-07-30T13:51:45Z",
+      "repoId": 987670088,
+      "pullRequestNo": 358
+    },
+    {
+      "name": "douglarek",
+      "id": 1488134,
+      "comment_id": 3136721507,
+      "created_at": "2025-07-30T14:55:51Z",
+      "repoId": 987670088,
+      "pullRequestNo": 362
+    },
+    {
+      "name": "taigrr",
+      "id": 8261498,
+      "comment_id": 3138718122,
+      "created_at": "2025-07-31T06:31:11Z",
+      "repoId": 987670088,
+      "pullRequestNo": 391
+    },
+    {
+      "name": "fluffypony",
+      "id": 1944293,
+      "comment_id": 3139828932,
+      "created_at": "2025-07-31T12:45:05Z",
+      "repoId": 987670088,
+      "pullRequestNo": 400
+    },
+    {
+      "name": "jedisct1",
+      "id": 124872,
+      "comment_id": 3140242221,
+      "created_at": "2025-07-31T14:39:23Z",
+      "repoId": 987670088,
+      "pullRequestNo": 408
+    },
+    {
+      "name": "Djiit",
+      "id": 1169844,
+      "comment_id": 3140319096,
+      "created_at": "2025-07-31T15:01:49Z",
+      "repoId": 987670088,
+      "pullRequestNo": 409
+    },
+    {
+      "name": "steipete",
+      "id": 58493,
+      "comment_id": 3140446226,
+      "created_at": "2025-07-31T15:40:05Z",
+      "repoId": 987670088,
+      "pullRequestNo": 414
+    },
+    {
+      "name": "lmn451",
+      "id": 14910239,
+      "comment_id": 3141170246,
+      "created_at": "2025-07-31T19:54:14Z",
+      "repoId": 987670088,
+      "pullRequestNo": 429
+    },
+    {
+      "name": "petersanchez",
+      "id": 199166,
+      "comment_id": 3141358800,
+      "created_at": "2025-07-31T21:14:55Z",
+      "repoId": 987670088,
+      "pullRequestNo": 434
+    },
+    {
+      "name": "alvaro17f",
+      "id": 89421445,
+      "comment_id": 3144148093,
+      "created_at": "2025-08-01T10:50:27Z",
+      "repoId": 987670088,
+      "pullRequestNo": 451
+    },
+    {
+      "name": "bbrodriges",
+      "id": 871322,
+      "comment_id": 3144263924,
+      "created_at": "2025-08-01T11:33:11Z",
+      "repoId": 987670088,
+      "pullRequestNo": 454
+    },
+    {
+      "name": "SyedaAnshrahGillani",
+      "id": 90501474,
+      "comment_id": 3144865858,
+      "created_at": "2025-08-01T14:57:07Z",
+      "repoId": 987670088,
+      "pullRequestNo": 460
+    },
+    {
+      "name": "spachava753",
+      "id": 34797853,
+      "comment_id": 3145329017,
+      "created_at": "2025-08-01T17:49:37Z",
+      "repoId": 987670088,
+      "pullRequestNo": 469
+    },
+    {
+      "name": "tabletcorry",
+      "id": 456754,
+      "comment_id": 3145908475,
+      "created_at": "2025-08-01T22:18:28Z",
+      "repoId": 987670088,
+      "pullRequestNo": 480
+    },
+    {
+      "name": "yumosx",
+      "id": 141902143,
+      "comment_id": 3146472558,
+      "created_at": "2025-08-02T12:24:29Z",
+      "repoId": 987670088,
+      "pullRequestNo": 504
+    },
+    {
+      "name": "bold84",
+      "id": 21118257,
+      "comment_id": 3146962342,
+      "created_at": "2025-08-03T04:07:16Z",
+      "repoId": 987670088,
+      "pullRequestNo": 519
+    },
+    {
+      "name": "jooray",
+      "id": 1028688,
+      "comment_id": 3148713433,
+      "created_at": "2025-08-03T21:35:15Z",
+      "repoId": 987670088,
+      "pullRequestNo": 527
+    },
+    {
+      "name": "Ed4ward",
+      "id": 153800328,
+      "comment_id": 3150375016,
+      "created_at": "2025-08-04T12:16:16Z",
+      "repoId": 987670088,
+      "pullRequestNo": 539
+    },
+    {
+      "name": "ngnhng",
+      "id": 51743767,
+      "comment_id": 3150846779,
+      "created_at": "2025-08-04T14:01:30Z",
+      "repoId": 987670088,
+      "pullRequestNo": 546
+    },
+    {
+      "name": "zloeber",
+      "id": 4702624,
+      "comment_id": 3152513500,
+      "created_at": "2025-08-04T21:55:42Z",
+      "repoId": 987670088,
+      "pullRequestNo": 564
+    },
+    {
+      "name": "nelsenm2",
+      "id": 197524521,
+      "comment_id": 3152872109,
+      "created_at": "2025-08-05T00:24:50Z",
+      "repoId": 987670088,
+      "pullRequestNo": 569
+    },
+    {
+      "name": "mohseenrm",
+      "id": 10768371,
+      "comment_id": 3153159347,
+      "created_at": "2025-08-05T03:39:12Z",
+      "repoId": 987670088,
+      "pullRequestNo": 574
+    },
+    {
+      "name": "0xWelt",
+      "id": 49543594,
+      "comment_id": 3157331134,
+      "created_at": "2025-08-06T04:07:52Z",
+      "repoId": 987670088,
+      "pullRequestNo": 584
+    },
+    {
+      "name": "kslamph",
+      "id": 15257433,
+      "comment_id": 3157402768,
+      "created_at": "2025-08-06T04:56:35Z",
+      "repoId": 987670088,
+      "pullRequestNo": 585
+    },
+    {
+      "name": "kslamph",
+      "id": 15257433,
+      "comment_id": 3157429309,
+      "created_at": "2025-08-06T05:14:23Z",
+      "repoId": 987670088,
+      "pullRequestNo": 585
+    },
+    {
+      "name": "Sunsvea",
+      "id": 14066471,
+      "comment_id": 3159014183,
+      "created_at": "2025-08-06T10:04:39Z",
+      "repoId": 987670088,
+      "pullRequestNo": 593
+    },
+    {
+      "name": "taciturnaxolotl",
+      "id": 92754843,
+      "comment_id": 3160702345,
+      "created_at": "2025-08-06T15:48:47Z",
+      "repoId": 987670088,
+      "pullRequestNo": 606
+    },
+    {
+      "name": "bashbunni",
+      "id": 15822994,
+      "comment_id": 3160746002,
+      "created_at": "2025-08-06T16:02:06Z",
+      "repoId": 987670088,
+      "pullRequestNo": 187
+    },
+    {
+      "name": "edafonseca",
+      "id": 3027921,
+      "comment_id": 3161714270,
+      "created_at": "2025-08-06T21:41:34Z",
+      "repoId": 987670088,
+      "pullRequestNo": 618
+    },
+    {
+      "name": "smores56",
+      "id": 22140449,
+      "comment_id": 3161853491,
+      "created_at": "2025-08-06T22:51:42Z",
+      "repoId": 987670088,
+      "pullRequestNo": 620
+    },
+    {
+      "name": "danielsz",
+      "id": 859131,
+      "comment_id": 3163327861,
+      "created_at": "2025-08-07T09:39:26Z",
+      "repoId": 987670088,
+      "pullRequestNo": 628
+    },
+    {
+      "name": "pavelzw",
+      "id": 29506042,
+      "comment_id": 3164728921,
+      "created_at": "2025-08-07T15:33:23Z",
+      "repoId": 987670088,
+      "pullRequestNo": 631
+    },
+    {
+      "name": "CyrusZei",
+      "id": 5053903,
+      "comment_id": 3165875211,
+      "created_at": "2025-08-07T21:45:30Z",
+      "repoId": 987670088,
+      "pullRequestNo": 638
+    },
+    {
+      "name": "maxjustus",
+      "id": 24899,
+      "comment_id": 3166599830,
+      "created_at": "2025-08-08T05:12:37Z",
+      "repoId": 987670088,
+      "pullRequestNo": 645
+    },
+    {
+      "name": "akaytatsu",
+      "id": 2520440,
+      "comment_id": 3167400968,
+      "created_at": "2025-08-08T10:32:51Z",
+      "repoId": 987670088,
+      "pullRequestNo": 647
+    },
+    {
+      "name": "theguy000",
+      "id": 52881001,
+      "comment_id": 3167442675,
+      "created_at": "2025-08-08T10:46:15Z",
+      "repoId": 987670088,
+      "pullRequestNo": 648
+    },
+    {
+      "name": "pwnintended",
+      "id": 92651319,
+      "comment_id": 3169309904,
+      "created_at": "2025-08-08T21:08:45Z",
+      "repoId": 987670088,
+      "pullRequestNo": 668
+    },
+    {
+      "name": "tazjin",
+      "id": 1552853,
+      "comment_id": 3169412729,
+      "created_at": "2025-08-08T22:05:40Z",
+      "repoId": 987670088,
+      "pullRequestNo": 672
+    },
+    {
+      "name": "liznear",
+      "id": 160093988,
+      "comment_id": 3170486027,
+      "created_at": "2025-08-09T08:15:27Z",
+      "repoId": 987670088,
+      "pullRequestNo": 681
+    },
+    {
+      "name": "jamestrew",
+      "id": 66286082,
+      "comment_id": 3171975481,
+      "created_at": "2025-08-09T17:55:31Z",
+      "repoId": 987670088,
+      "pullRequestNo": 689
+    },
+    {
+      "name": "wwwjfy",
+      "id": 126527,
+      "comment_id": 3172676799,
+      "created_at": "2025-08-10T14:35:04Z",
+      "repoId": 987670088,
+      "pullRequestNo": 702
+    },
+    {
+      "name": "orospakr",
+      "id": 16714,
+      "comment_id": 3181859171,
+      "created_at": "2025-08-13T01:01:30Z",
+      "repoId": 987670088,
+      "pullRequestNo": 746
+    },
+    {
+      "name": "samiulsami",
+      "id": 33352407,
+      "comment_id": 3189231059,
+      "created_at": "2025-08-14T17:12:20Z",
+      "repoId": 987670088,
+      "pullRequestNo": 779
+    },
+    {
+      "name": "neomantra",
+      "id": 26842,
+      "comment_id": 3189674073,
+      "created_at": "2025-08-14T19:42:53Z",
+      "repoId": 987670088,
+      "pullRequestNo": 752
+    },
+    {
+      "name": "uri",
+      "id": 676443,
+      "comment_id": 3190313833,
+      "created_at": "2025-08-15T00:58:11Z",
+      "repoId": 987670088,
+      "pullRequestNo": 782
+    },
+    {
+      "name": "lpmitchell",
+      "id": 5081038,
+      "comment_id": 3191789654,
+      "created_at": "2025-08-15T15:23:59Z",
+      "repoId": 987670088,
+      "pullRequestNo": 790
+    },
+    {
+      "name": "marcosktsz",
+      "id": 58952492,
+      "comment_id": 3193569650,
+      "created_at": "2025-08-16T10:29:10Z",
+      "repoId": 987670088,
+      "pullRequestNo": 798
+    },
+    {
+      "name": "sainadh-d",
+      "id": 15155045,
+      "comment_id": 3193680786,
+      "created_at": "2025-08-16T13:49:03Z",
+      "repoId": 987670088,
+      "pullRequestNo": 803
+    },
+    {
+      "name": "ericcoleta",
+      "id": 42539971,
+      "comment_id": 3201263288,
+      "created_at": "2025-08-19T15:38:48Z",
+      "repoId": 987670088,
+      "pullRequestNo": 835
+    },
+    {
+      "name": "linw1995",
+      "id": 13523027,
+      "comment_id": 3209540243,
+      "created_at": "2025-08-21T08:29:20Z",
+      "repoId": 987670088,
+      "pullRequestNo": 850
+    },
+    {
+      "name": "khareyash05",
+      "id": 60147732,
+      "comment_id": 3213528951,
+      "created_at": "2025-08-22T08:26:23Z",
+      "repoId": 987670088,
+      "pullRequestNo": 860
+    },
+    {
+      "name": "mpj",
+      "id": 17815,
+      "comment_id": 3214796891,
+      "created_at": "2025-08-22T15:35:12Z",
+      "repoId": 987670088,
+      "pullRequestNo": 865
+    },
+    {
+      "name": "xPrimeTime",
+      "id": 101987372,
+      "comment_id": 3217970106,
+      "created_at": "2025-08-24T09:28:11Z",
+      "repoId": 987670088,
+      "pullRequestNo": 873
+    },
+    {
+      "name": "mercmobily",
+      "id": 2128734,
+      "comment_id": 3219992206,
+      "created_at": "2025-08-25T12:00:54Z",
+      "repoId": 987670088,
+      "pullRequestNo": 882
+    },
+    {
+      "name": "xhos",
+      "id": 60789741,
+      "comment_id": 3221119175,
+      "created_at": "2025-08-25T17:26:06Z",
+      "repoId": 987670088,
+      "pullRequestNo": 892
+    },
+    {
+      "name": "henrebotha",
+      "id": 5593874,
+      "comment_id": 3223793535,
+      "created_at": "2025-08-26T11:34:17Z",
+      "repoId": 987670088,
+      "pullRequestNo": 900
+    },
+    {
+      "name": "negz",
+      "id": 1049349,
+      "comment_id": 3232462357,
+      "created_at": "2025-08-28T08:23:46Z",
+      "repoId": 987670088,
+      "pullRequestNo": 914
+    },
+    {
+      "name": "undo76",
+      "id": 1415667,
+      "comment_id": 3235052544,
+      "created_at": "2025-08-28T21:53:00Z",
+      "repoId": 987670088,
+      "pullRequestNo": 921
+    },
+    {
+      "name": "andersonjoseph",
+      "id": 22438127,
+      "comment_id": 3237655829,
+      "created_at": "2025-08-29T16:54:00Z",
+      "repoId": 987670088,
+      "pullRequestNo": 926
+    },
+    {
+      "name": "tisDDM",
+      "id": 77615100,
+      "comment_id": 3240239275,
+      "created_at": "2025-08-31T15:58:52Z",
+      "repoId": 987670088,
+      "pullRequestNo": 944
+    }
+  ]
+}

projects/ui/crush/.github/dependabot.yml

@@ -0,0 +1,36 @@
+version: 2
+
+updates:
+  - package-ecosystem: "gomod"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+      time: "05:00"
+      timezone: "America/New_York"
+    labels:
+      - "area: dependencies"
+    commit-message:
+      prefix: "chore"
+      include: "scope"
+    groups:
+      all:
+        patterns:
+          - "*"
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+      time: "05:00"
+      timezone: "America/New_York"
+    labels:
+      - "area: dependencies"
+    commit-message:
+      prefix: "chore"
+      include: "scope"
+    groups:
+      all:
+        patterns:
+          - "*"

projects/ui/crush/.github/entitlements.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+    <true/>
+  </dict>
+</plist>

projects/ui/crush/.github/labeler.yml

@@ -0,0 +1,63 @@
+# NOTE(@andreynering): We should have a single entry per label, because if we
+# have multiple the action would only apply the label if ALL of them match.
+
+"area: ci":
+  - "/^ci: /i"
+"area: diff":
+  - "/diff/i"
+"area: docs":
+  - "/(docs|documentation|readme)/i"
+"area: images":
+  - "/image/i"
+"area: lsp":
+  - "/lsp/i"
+"area: mcp":
+  - "/mcp/i"
+"area: mouse":
+  - "/(mouse|scroll)/i"
+"area: onboarding":
+  - "/(onboarding)/i"
+"area: permissions":
+  - "/permission/i"
+"area: releasing":
+  - "/(release|releasing|aur|brew|nix|npm|scoop|termux|winget)/i"
+"area: session":
+  - "/session/i"
+"area: shell":
+  - "/shell/i"
+"area: themes":
+  - "/theme/i"
+"area: tools":
+  - "/tool/i"
+"os: android":
+  - "/(android|termux)/i"
+"os: linux":
+  - "/(linux|fedora|debian|ubuntu)/i"
+"os: macos":
+  - "/(macos|osx|darwin)/i"
+"os: windows":
+  - "/(windows|win10|win11|win32|wsl|scoop|winget)/i"
+"panic / crash":
+  - "/(panic|crash|segfault)/i"
+"provider: anthropic claude":
+  - "/(anthropic|claude)/i"
+"provider: aws bedrock":
+  - "/(aws|bedrock)/i"
+"provider: google gemini":
+  - "/gemini/i"
+"provider: google vertex":
+  - "/vertex/i"
+"provider: kimi":
+  - "/kimi/i"
+"provider: ollama":
+  - "/llama/i"
+"provider: openai chatgpt":
+  - "/(openai|gpt)/i"
+"provider: openrouter":
+  - "/openrouter/i"
+"provider: qwen":
+  - "/qwen/i"
+"provider: xai grok":
+  - "/(xai|x\\.ai|grok)/i"
+"security":
+  - "/(security|vulnerability|exploit)/i"

projects/ui/crush/.github/workflows/build.yml

@@ -0,0 +1,11 @@
+name: build
+on: [push, pull_request]
+
+jobs:
+  build:
+    uses: charmbracelet/meta/.github/workflows/build.yml@main
+    with:
+      go-version: ""
+      go-version-file: ./go.mod
+    secrets:
+      gh_pat: "${{ secrets.PERSONAL_ACCESS_TOKEN }}"

projects/ui/crush/.github/workflows/cla.yml

@@ -0,0 +1,36 @@
+name: "CLA Assistant"
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_target:
+    types: [opened, closed, synchronize]
+
+permissions:
+  actions: write
+  contents: write
+  pull-requests: write
+  statuses: write
+
+jobs:
+  CLAAssistant:
+    if: github.repository == 'charmbracelet/crush'
+    runs-on: ubuntu-latest
+    steps:
+      - name: "CLA Assistant"
+        if: |
+          github.event.comment.body == 'recheck' ||
+          github.event.comment.body == 'I have read the Contributor License Agreement (CLA) and hereby sign the CLA.' ||
+          github.event_name == 'pull_request_target'
+        uses: contributor-assistant/github-action@v2.6.1
+        env:
+          GITHUB_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
+        with:
+          path-to-signatures: ".github/cla-signatures.json"
+          path-to-document: "https://github.com/charmbracelet/crush/blob/main/CLA.md"
+          branch: "main"
+          allowlist: charmcli,charmcrush,dependabot[bot]
+          custom-pr-sign-comment: "I have read the Contributor License Agreement (CLA) and hereby sign the CLA."
+          custom-notsigned-prcomment: "Thank you for your submission. We really appreciate it! Like many open-source projects, we ask that you sign our [Contributor License Agreement](https://github.com/charmbracelet/crush/blob/main/CLA.md) before we can accept your contribution. You can sign the CLA by just posting a Pull Request comment same as the below format."
+          lock-pullrequest-aftermerge: false
+          signed-commit-message: "chore(legal): @$contributorName has signed the CLA"

projects/ui/crush/.github/workflows/labeler.yml

@@ -0,0 +1,30 @@
+name: labeler
+
+on:
+  issues:
+    types: [opened]
+  pull_request_target:
+    types: [opened]
+  workflow_dispatch:
+    inputs:
+      issue-number:
+        description: "Issue/PR #"
+        required: true
+        type: string
+
+permissions:
+  issues: write
+  contents: read
+
+jobs:
+  triage:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: github/issue-labeler@v3.4
+        with:
+          configuration-path: .github/labeler.yml
+          enable-versioned-regex: 0
+          include-title: 1
+          include-body: 0
+          repo-token: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
+          issue-number: ${{ github.event.inputs.issue-number || github.event.issue.number || github.event.pull_request.number }}

projects/ui/crush/.github/workflows/lint-sync.yml

@@ -0,0 +1,14 @@
+name: lint-sync
+on:
+  schedule:
+    # every Sunday at midnight
+    - cron: "0 0 * * 0"
+  workflow_dispatch: # allows manual triggering
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  lint:
+    uses: charmbracelet/meta/.github/workflows/lint-sync.yml@main

projects/ui/crush/.github/workflows/lint.yml

@@ -0,0 +1,12 @@
+name: lint
+on:
+  push:
+  pull_request:
+
+jobs:
+  lint:
+    uses: charmbracelet/meta/.github/workflows/lint.yml@main
+    with:
+      golangci_path: .golangci.yml
+      golangci_version: v2.4
+      timeout: 10m

projects/ui/crush/.github/workflows/nightly.yml

@@ -0,0 +1,31 @@
+name: nightly
+
+on:
+  schedule:
+    - cron: "0 0 * * *" # every day at midnight
+  workflow_dispatch: # allows manual triggering
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    outputs:
+      should_run: ${{ steps.check.outputs.should_run }}
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 1
+      - id: check
+        env:
+          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
+        run: |
+          if gh run list --workflow nightly.yml -c $(git rev-parse HEAD) -s success | grep 'completed'; then
+            echo "should_run=false" >> $GITHUB_OUTPUT
+          else
+            echo "should_run=true" >> $GITHUB_OUTPUT
+          fi
+  nightly:
+    needs: check
+    if: needs.check.outputs.should_run == 'true'
+    uses: charmbracelet/meta/.github/workflows/nightly.yml@main
+    secrets:
+      goreleaser_key: ${{ secrets.GORELEASER_KEY }}

projects/ui/crush/.github/workflows/release.yml

@@ -0,0 +1,35 @@
+# yaml-language-server: $schema=https://json.schemastore.org/github-workflow.json
+
+name: goreleaser
+
+on:
+  push:
+    tags:
+      - v*.*.*
+
+concurrency:
+  group: goreleaser
+  cancel-in-progress: true
+
+jobs:
+  goreleaser:
+    uses: charmbracelet/meta/.github/workflows/goreleaser.yml@main
+    with:
+      go_version: "1.25"
+      macos_sign_entitlements: "./.github/entitlements.plist"
+    secrets:
+      docker_username: ${{ secrets.DOCKERHUB_USERNAME }}
+      docker_token: ${{ secrets.DOCKERHUB_TOKEN }}
+      gh_pat: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
+      goreleaser_key: ${{ secrets.GORELEASER_KEY }}
+      fury_token: ${{ secrets.FURY_TOKEN }}
+      nfpm_gpg_key: ${{ secrets.NFPM_GPG_KEY }}
+      nfpm_passphrase: ${{ secrets.NFPM_PASSPHRASE }}
+      npm_token: ${{ secrets.NPM_TOKEN }}
+      snapcraft_token: ${{ secrets.SNAPCRAFT_TOKEN }}
+      aur_key: ${{ secrets.AUR_KEY }}
+      macos_sign_p12: ${{ secrets.MACOS_SIGN_P12 }}
+      macos_sign_password: ${{ secrets.MACOS_SIGN_PASSWORD }}
+      macos_notary_issuer_id: ${{ secrets.MACOS_NOTARY_ISSUER_ID }}
+      macos_notary_key_id: ${{ secrets.MACOS_NOTARY_KEY_ID }}
+      macos_notary_key: ${{ secrets.MACOS_NOTARY_KEY }}

projects/ui/crush/.github/workflows/schema-update.yml

@@ -0,0 +1,26 @@
+name: Update Schema
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - "internal/config/**"
+
+jobs:
+  update-schema:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          token: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+      - run: go run . schema > ./schema.json
+      - uses: stefanzweifel/git-auto-commit-action@778341af668090896ca464160c2def5d1d1a3eb0 # v5
+        with:
+          commit_message: "chore: auto-update generated files"
+          branch: main
+          commit_user_name: actions-user
+          commit_user_email: actions@github.com
+          commit_author: actions-user <actions@github.com>

projects/ui/crush/internal/ansiext/ansi.go

@@ -0,0 +1,25 @@
+package ansiext
+
+import (
+	"strings"
+
+	"github.com/charmbracelet/x/ansi"
+)
+
+// Escape replaces control characters with their Unicode Control Picture
+// representations to ensure they are displayed correctly in the UI.
+func Escape(content string) string {
+	var sb strings.Builder
+	sb.Grow(len(content))
+	for _, r := range content {
+		switch {
+		case r >= 0 && r <= 0x1f: // Control characters 0x00-0x1F
+			sb.WriteRune('\u2400' + r)
+		case r == ansi.DEL:
+			sb.WriteRune('\u2421')
+		default:
+			sb.WriteRune(r)
+		}
+	}
+	return sb.String()
+}

projects/ui/crush/internal/app/app.go

@@ -0,0 +1,356 @@
+package app
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"log/slog"
+	"maps"
+	"sync"
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea/v2"
+	"github.com/charmbracelet/crush/internal/config"
+	"github.com/charmbracelet/crush/internal/csync"
+	"github.com/charmbracelet/crush/internal/db"
+	"github.com/charmbracelet/crush/internal/format"
+	"github.com/charmbracelet/crush/internal/history"
+	"github.com/charmbracelet/crush/internal/llm/agent"
+	"github.com/charmbracelet/crush/internal/log"
+	"github.com/charmbracelet/crush/internal/pubsub"
+
+	"github.com/charmbracelet/crush/internal/lsp"
+	"github.com/charmbracelet/crush/internal/message"
+	"github.com/charmbracelet/crush/internal/permission"
+	"github.com/charmbracelet/crush/internal/session"
+)
+
+type App struct {
+	Sessions    session.Service
+	Messages    message.Service
+	History     history.Service
+	Permissions permission.Service
+
+	CoderAgent agent.Service
+
+	LSPClients map[string]*lsp.Client
+
+	clientsMutex sync.RWMutex
+
+	watcherCancelFuncs *csync.Slice[context.CancelFunc]
+	lspWatcherWG       sync.WaitGroup
+
+	config *config.Config
+
+	serviceEventsWG *sync.WaitGroup
+	eventsCtx       context.Context
+	events          chan tea.Msg
+	tuiWG           *sync.WaitGroup
+
+	// global context and cleanup functions
+	globalCtx    context.Context
+	cleanupFuncs []func()
+}
+
+// New initializes a new applcation instance.
+func New(ctx context.Context, conn *sql.DB, cfg *config.Config) (*App, error) {
+	q := db.New(conn)
+	sessions := session.NewService(q)
+	messages := message.NewService(q)
+	files := history.NewService(q, conn)
+	skipPermissionsRequests := cfg.Permissions != nil && cfg.Permissions.SkipRequests
+	allowedTools := []string{}
+	if cfg.Permissions != nil && cfg.Permissions.AllowedTools != nil {
+		allowedTools = cfg.Permissions.AllowedTools
+	}
+
+	app := &App{
+		Sessions:    sessions,
+		Messages:    messages,
+		History:     files,
+		Permissions: permission.NewPermissionService(cfg.WorkingDir(), skipPermissionsRequests, allowedTools),
+		LSPClients:  make(map[string]*lsp.Client),
+
+		globalCtx: ctx,
+
+		config: cfg,
+
+		watcherCancelFuncs: csync.NewSlice[context.CancelFunc](),
+
+		events:          make(chan tea.Msg, 100),
+		serviceEventsWG: &sync.WaitGroup{},
+		tuiWG:           &sync.WaitGroup{},
+	}
+
+	app.setupEvents()
+
+	// Initialize LSP clients in the background.
+	app.initLSPClients(ctx)
+
+	// TODO: remove the concept of agent config, most likely.
+	if cfg.IsConfigured() {
+		if err := app.InitCoderAgent(); err != nil {
+			return nil, fmt.Errorf("failed to initialize coder agent: %w", err)
+		}
+	} else {
+		slog.Warn("No agent configuration found")
+	}
+	return app, nil
+}
+
+// Config returns the application configuration.
+func (app *App) Config() *config.Config {
+	return app.config
+}
+
+// RunNonInteractive handles the execution flow when a prompt is provided via
+// CLI flag.
+func (app *App) RunNonInteractive(ctx context.Context, prompt string, quiet bool) error {
+	slog.Info("Running in non-interactive mode")
+
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	// Start spinner if not in quiet mode.
+	var spinner *format.Spinner
+	if !quiet {
+		spinner = format.NewSpinner(ctx, cancel, "Generating")
+		spinner.Start()
+	}
+
+	// Helper function to stop spinner once.
+	stopSpinner := func() {
+		if !quiet && spinner != nil {
+			spinner.Stop()
+			spinner = nil
+		}
+	}
+	defer stopSpinner()
+
+	const maxPromptLengthForTitle = 100
+	titlePrefix := "Non-interactive: "
+	var titleSuffix string
+
+	if len(prompt) > maxPromptLengthForTitle {
+		titleSuffix = prompt[:maxPromptLengthForTitle] + "..."
+	} else {
+		titleSuffix = prompt
+	}
+	title := titlePrefix + titleSuffix
+
+	sess, err := app.Sessions.Create(ctx, title)
+	if err != nil {
+		return fmt.Errorf("failed to create session for non-interactive mode: %w", err)
+	}
+	slog.Info("Created session for non-interactive run", "session_id", sess.ID)
+
+	// Automatically approve all permission requests for this non-interactive session
+	app.Permissions.AutoApproveSession(sess.ID)
+
+	done, err := app.CoderAgent.Run(ctx, sess.ID, prompt)
+	if err != nil {
+		return fmt.Errorf("failed to start agent processing stream: %w", err)
+	}
+
+	messageEvents := app.Messages.Subscribe(ctx)
+	messageReadBytes := make(map[string]int)
+
+	for {
+		select {
+		case result := <-done:
+			stopSpinner()
+
+			if result.Error != nil {
+				if errors.Is(result.Error, context.Canceled) || errors.Is(result.Error, agent.ErrRequestCancelled) {
+					slog.Info("Non-interactive: agent processing cancelled", "session_id", sess.ID)
+					return nil
+				}
+				return fmt.Errorf("agent processing failed: %w", result.Error)
+			}
+
+			msgContent := result.Message.Content().String()
+			readBts := messageReadBytes[result.Message.ID]
+
+			if len(msgContent) < readBts {
+				slog.Error("Non-interactive: message content is shorter than read bytes", "message_length", len(msgContent), "read_bytes", readBts)
+				return fmt.Errorf("message content is shorter than read bytes: %d < %d", len(msgContent), readBts)
+			}
+			fmt.Println(msgContent[readBts:])
+			messageReadBytes[result.Message.ID] = len(msgContent)
+
+			slog.Info("Non-interactive: run completed", "session_id", sess.ID)
+			return nil
+
+		case event := <-messageEvents:
+			msg := event.Payload
+			if msg.SessionID == sess.ID && msg.Role == message.Assistant && len(msg.Parts) > 0 {
+				stopSpinner()
+
+				content := msg.Content().String()
+				readBytes := messageReadBytes[msg.ID]
+
+				if len(content) < readBytes {
+					slog.Error("Non-interactive: message content is shorter than read bytes", "message_length", len(content), "read_bytes", readBytes)
+					return fmt.Errorf("message content is shorter than read bytes: %d < %d", len(content), readBytes)
+				}
+
+				part := content[readBytes:]
+				fmt.Print(part)
+				messageReadBytes[msg.ID] = len(content)
+			}
+
+		case <-ctx.Done():
+			stopSpinner()
+			return ctx.Err()
+		}
+	}
+}
+
+func (app *App) UpdateAgentModel() error {
+	return app.CoderAgent.UpdateModel()
+}
+
+func (app *App) setupEvents() {
+	ctx, cancel := context.WithCancel(app.globalCtx)
+	app.eventsCtx = ctx
+	setupSubscriber(ctx, app.serviceEventsWG, "sessions", app.Sessions.Subscribe, app.events)
+	setupSubscriber(ctx, app.serviceEventsWG, "messages", app.Messages.Subscribe, app.events)
+	setupSubscriber(ctx, app.serviceEventsWG, "permissions", app.Permissions.Subscribe, app.events)
+	setupSubscriber(ctx, app.serviceEventsWG, "permissions-notifications", app.Permissions.SubscribeNotifications, app.events)
+	setupSubscriber(ctx, app.serviceEventsWG, "history", app.History.Subscribe, app.events)
+	setupSubscriber(ctx, app.serviceEventsWG, "mcp", agent.SubscribeMCPEvents, app.events)
+	setupSubscriber(ctx, app.serviceEventsWG, "lsp", SubscribeLSPEvents, app.events)
+	cleanupFunc := func() {
+		cancel()
+		app.serviceEventsWG.Wait()
+	}
+	app.cleanupFuncs = append(app.cleanupFuncs, cleanupFunc)
+}
+
+func setupSubscriber[T any](
+	ctx context.Context,
+	wg *sync.WaitGroup,
+	name string,
+	subscriber func(context.Context) <-chan pubsub.Event[T],
+	outputCh chan<- tea.Msg,
+) {
+	wg.Go(func() {
+		subCh := subscriber(ctx)
+		for {
+			select {
+			case event, ok := <-subCh:
+				if !ok {
+					slog.Debug("subscription channel closed", "name", name)
+					return
+				}
+				var msg tea.Msg = event
+				select {
+				case outputCh <- msg:
+				case <-time.After(2 * time.Second):
+					slog.Warn("message dropped due to slow consumer", "name", name)
+				case <-ctx.Done():
+					slog.Debug("subscription cancelled", "name", name)
+					return
+				}
+			case <-ctx.Done():
+				slog.Debug("subscription cancelled", "name", name)
+				return
+			}
+		}
+	})
+}
+
+func (app *App) InitCoderAgent() error {
+	coderAgentCfg := app.config.Agents["coder"]
+	if coderAgentCfg.ID == "" {
+		return fmt.Errorf("coder agent configuration is missing")
+	}
+	var err error
+	app.CoderAgent, err = agent.NewAgent(
+		app.globalCtx,
+		coderAgentCfg,
+		app.Permissions,
+		app.Sessions,
+		app.Messages,
+		app.History,
+		app.LSPClients,
+	)
+	if err != nil {
+		slog.Error("Failed to create coder agent", "err", err)
+		return err
+	}
+
+	// Add MCP client cleanup to shutdown process
+	app.cleanupFuncs = append(app.cleanupFuncs, agent.CloseMCPClients)
+
+	setupSubscriber(app.eventsCtx, app.serviceEventsWG, "coderAgent", app.CoderAgent.Subscribe, app.events)
+	return nil
+}
+
+// Subscribe sends events to the TUI as tea.Msgs.
+func (app *App) Subscribe(program *tea.Program) {
+	defer log.RecoverPanic("app.Subscribe", func() {
+		slog.Info("TUI subscription panic: attempting graceful shutdown")
+		program.Quit()
+	})
+
+	app.tuiWG.Add(1)
+	tuiCtx, tuiCancel := context.WithCancel(app.globalCtx)
+	app.cleanupFuncs = append(app.cleanupFuncs, func() {
+		slog.Debug("Cancelling TUI message handler")
+		tuiCancel()
+		app.tuiWG.Wait()
+	})
+	defer app.tuiWG.Done()
+
+	for {
+		select {
+		case <-tuiCtx.Done():
+			slog.Debug("TUI message handler shutting down")
+			return
+		case msg, ok := <-app.events:
+			if !ok {
+				slog.Debug("TUI message channel closed")
+				return
+			}
+			program.Send(msg)
+		}
+	}
+}
+
+// Shutdown performs a graceful shutdown of the application.
+func (app *App) Shutdown() {
+	if app.CoderAgent != nil {
+		app.CoderAgent.CancelAll()
+	}
+
+	for cancel := range app.watcherCancelFuncs.Seq() {
+		cancel()
+	}
+
+	// Wait for all LSP watchers to finish.
+	app.lspWatcherWG.Wait()
+
+	// Get all LSP clients.
+	app.clientsMutex.RLock()
+	clients := make(map[string]*lsp.Client, len(app.LSPClients))
+	maps.Copy(clients, app.LSPClients)
+	app.clientsMutex.RUnlock()
+
+	// Shutdown all LSP clients.
+	for name, client := range clients {
+		shutdownCtx, cancel := context.WithTimeout(app.globalCtx, 5*time.Second)
+		if err := client.Shutdown(shutdownCtx); err != nil {
+			slog.Error("Failed to shutdown LSP client", "name", name, "error", err)
+		}
+		cancel()
+	}
+
+	// Call call cleanup functions.
+	for _, cleanup := range app.cleanupFuncs {
+		if cleanup != nil {
+			cleanup()
+		}
+	}
+}

projects/ui/crush/internal/app/lsp.go

@@ -0,0 +1,129 @@
+package app
+
+import (
+	"context"
+	"log/slog"
+	"time"
+
+	"github.com/charmbracelet/crush/internal/config"
+	"github.com/charmbracelet/crush/internal/log"
+	"github.com/charmbracelet/crush/internal/lsp"
+	"github.com/charmbracelet/crush/internal/lsp/watcher"
+)
+
+// initLSPClients initializes LSP clients.
+func (app *App) initLSPClients(ctx context.Context) {
+	for name, clientConfig := range app.config.LSP {
+		go app.createAndStartLSPClient(ctx, name, clientConfig)
+	}
+	slog.Info("LSP clients initialization started in background")
+}
+
+// createAndStartLSPClient creates a new LSP client, initializes it, and starts its workspace watcher
+func (app *App) createAndStartLSPClient(ctx context.Context, name string, config config.LSPConfig) {
+	slog.Info("Creating LSP client", "name", name, "command", config.Command, "fileTypes", config.FileTypes, "args", config.Args)
+
+	// Update state to starting
+	updateLSPState(name, lsp.StateStarting, nil, nil, 0)
+
+	// Create LSP client.
+	lspClient, err := lsp.NewClient(ctx, name, config)
+	if err != nil {
+		slog.Error("Failed to create LSP client for", name, err)
+		updateLSPState(name, lsp.StateError, err, nil, 0)
+		return
+	}
+
+	// Set diagnostics callback
+	lspClient.SetDiagnosticsCallback(updateLSPDiagnostics)
+
+	// Increase initialization timeout as some servers take more time to start.
+	initCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
+	defer cancel()
+
+	// Initialize LSP client.
+	_, err = lspClient.InitializeLSPClient(initCtx, app.config.WorkingDir())
+	if err != nil {
+		slog.Error("Initialize failed", "name", name, "error", err)
+		updateLSPState(name, lsp.StateError, err, lspClient, 0)
+		lspClient.Close()
+		return
+	}
+
+	// Wait for the server to be ready.
+	if err := lspClient.WaitForServerReady(initCtx); err != nil {
+		slog.Error("Server failed to become ready", "name", name, "error", err)
+		// Server never reached a ready state, but let's continue anyway, as
+		// some functionality might still work.
+		lspClient.SetServerState(lsp.StateError)
+		updateLSPState(name, lsp.StateError, err, lspClient, 0)
+	} else {
+		// Server reached a ready state scuccessfully.
+		slog.Info("LSP server is ready", "name", name)
+		lspClient.SetServerState(lsp.StateReady)
+		updateLSPState(name, lsp.StateReady, nil, lspClient, 0)
+	}
+
+	slog.Info("LSP client initialized", "name", name)
+
+	// Create a child context that can be canceled when the app is shutting
+	// down.
+	watchCtx, cancelFunc := context.WithCancel(ctx)
+
+	// Create the workspace watcher.
+	workspaceWatcher := watcher.NewWorkspaceWatcher(name, lspClient)
+
+	// Store the cancel function to be called during cleanup.
+	app.watcherCancelFuncs.Append(cancelFunc)
+
+	// Add to map with mutex protection before starting goroutine
+	app.clientsMutex.Lock()
+	app.LSPClients[name] = lspClient
+	app.clientsMutex.Unlock()
+
+	// Run workspace watcher.
+	app.lspWatcherWG.Add(1)
+	go app.runWorkspaceWatcher(watchCtx, name, workspaceWatcher)
+}
+
+// runWorkspaceWatcher executes the workspace watcher for an LSP client.
+func (app *App) runWorkspaceWatcher(ctx context.Context, name string, workspaceWatcher *watcher.WorkspaceWatcher) {
+	defer app.lspWatcherWG.Done()
+	defer log.RecoverPanic("LSP-"+name, func() {
+		// Try to restart the client.
+		app.restartLSPClient(ctx, name)
+	})
+
+	workspaceWatcher.WatchWorkspace(ctx, app.config.WorkingDir())
+	slog.Info("Workspace watcher stopped", "client", name)
+}
+
+// restartLSPClient attempts to restart a crashed or failed LSP client.
+func (app *App) restartLSPClient(ctx context.Context, name string) {
+	// Get the original configuration.
+	clientConfig, exists := app.config.LSP[name]
+	if !exists {
+		slog.Error("Cannot restart client, configuration not found", "client", name)
+		return
+	}
+
+	// Clean up the old client if it exists.
+	app.clientsMutex.Lock()
+	oldClient, exists := app.LSPClients[name]
+	if exists {
+		// Remove from map before potentially slow shutdown.
+		delete(app.LSPClients, name)
+	}
+	app.clientsMutex.Unlock()
+
+	if exists && oldClient != nil {
+		// Try to shut down client gracefully, but don't block on errors.
+		shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		_ = oldClient.Shutdown(shutdownCtx)
+		cancel()
+	}
+
+	// Create a new client using the shared function.
+	app.createAndStartLSPClient(ctx, name, clientConfig)
+	slog.Info("Successfully restarted LSP client", "client", name)
+}

projects/ui/crush/internal/app/lsp_events.go

@@ -0,0 +1,99 @@
+package app
+
+import (
+	"context"
+	"maps"
+	"time"
+
+	"github.com/charmbracelet/crush/internal/csync"
+	"github.com/charmbracelet/crush/internal/lsp"
+	"github.com/charmbracelet/crush/internal/pubsub"
+)
+
+// LSPEventType represents the type of LSP event
+type LSPEventType string
+
+const (
+	LSPEventStateChanged       LSPEventType = "state_changed"
+	LSPEventDiagnosticsChanged LSPEventType = "diagnostics_changed"
+)
+
+// LSPEvent represents an event in the LSP system
+type LSPEvent struct {
+	Type            LSPEventType
+	Name            string
+	State           lsp.ServerState
+	Error           error
+	DiagnosticCount int
+}
+
+// LSPClientInfo holds information about an LSP client's state
+type LSPClientInfo struct {
+	Name            string
+	State           lsp.ServerState
+	Error           error
+	Client          *lsp.Client
+	DiagnosticCount int
+	ConnectedAt     time.Time
+}
+
+var (
+	lspStates = csync.NewMap[string, LSPClientInfo]()
+	lspBroker = pubsub.NewBroker[LSPEvent]()
+)
+
+// SubscribeLSPEvents returns a channel for LSP events
+func SubscribeLSPEvents(ctx context.Context) <-chan pubsub.Event[LSPEvent] {
+	return lspBroker.Subscribe(ctx)
+}
+
+// GetLSPStates returns the current state of all LSP clients
+func GetLSPStates() map[string]LSPClientInfo {
+	return maps.Collect(lspStates.Seq2())
+}
+
+// GetLSPState returns the state of a specific LSP client
+func GetLSPState(name string) (LSPClientInfo, bool) {
+	return lspStates.Get(name)
+}
+
+// updateLSPState updates the state of an LSP client and publishes an event
+func updateLSPState(name string, state lsp.ServerState, err error, client *lsp.Client, diagnosticCount int) {
+	info := LSPClientInfo{
+		Name:            name,
+		State:           state,
+		Error:           err,
+		Client:          client,
+		DiagnosticCount: diagnosticCount,
+	}
+	if state == lsp.StateReady {
+		info.ConnectedAt = time.Now()
+	}
+	lspStates.Set(name, info)
+
+	// Publish state change event
+	lspBroker.Publish(pubsub.UpdatedEvent, LSPEvent{
+		Type:            LSPEventStateChanged,
+		Name:            name,
+		State:           state,
+		Error:           err,
+		DiagnosticCount: diagnosticCount,
+	})
+}
+
+// updateLSPDiagnostics updates the diagnostic count for an LSP client and publishes an event
+func updateLSPDiagnostics(name string, diagnosticCount int) {
+	if info, exists := lspStates.Get(name); exists {
+		info.DiagnosticCount = diagnosticCount
+		lspStates.Set(name, info)
+
+		// Publish diagnostics change event
+		lspBroker.Publish(pubsub.UpdatedEvent, LSPEvent{
+			Type:            LSPEventDiagnosticsChanged,
+			Name:            name,
+			State:           info.State,
+			Error:           info.Error,
+			DiagnosticCount: diagnosticCount,
+		})
+	}
+}

projects/ui/crush/internal/cmd/logs.go

@@ -0,0 +1,212 @@
+package cmd
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"slices"
+	"time"
+
+	"github.com/charmbracelet/crush/internal/config"
+	"github.com/charmbracelet/log/v2"
+	"github.com/nxadm/tail"
+	"github.com/spf13/cobra"
+)
+
+const defaultTailLines = 1000
+
+var logsCmd = &cobra.Command{
+	Use:   "logs",
+	Short: "View crush logs",
+	Long:  `View the logs generated by Crush. This command allows you to see the log output for debugging and monitoring.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		cwd, err := cmd.Flags().GetString("cwd")
+		if err != nil {
+			return fmt.Errorf("failed to get current working directory: %v", err)
+		}
+
+		dataDir, err := cmd.Flags().GetString("data-dir")
+		if err != nil {
+			return fmt.Errorf("failed to get data directory: %v", err)
+		}
+
+		follow, err := cmd.Flags().GetBool("follow")
+		if err != nil {
+			return fmt.Errorf("failed to get follow flag: %v", err)
+		}
+
+		tailLines, err := cmd.Flags().GetInt("tail")
+		if err != nil {
+			return fmt.Errorf("failed to get tail flag: %v", err)
+		}
+
+		log.SetLevel(log.DebugLevel)
+		log.SetOutput(os.Stdout)
+
+		cfg, err := config.Load(cwd, dataDir, false)
+		if err != nil {
+			return fmt.Errorf("failed to load configuration: %v", err)
+		}
+		logsFile := filepath.Join(cfg.Options.DataDirectory, "logs", "crush.log")
+		_, err = os.Stat(logsFile)
+		if os.IsNotExist(err) {
+			log.Warn("Looks like you are not in a crush project. No logs found.")
+			return nil
+		}
+
+		if follow {
+			return followLogs(cmd.Context(), logsFile, tailLines)
+		}
+
+		return showLogs(logsFile, tailLines)
+	},
+}
+
+func init() {
+	logsCmd.Flags().BoolP("follow", "f", false, "Follow log output")
+	logsCmd.Flags().IntP("tail", "t", defaultTailLines, "Show only the last N lines default: 1000 for performance")
+	rootCmd.AddCommand(logsCmd)
+}
+
+func followLogs(ctx context.Context, logsFile string, tailLines int) error {
+	t, err := tail.TailFile(logsFile, tail.Config{
+		Follow: false,
+		ReOpen: false,
+		Logger: tail.DiscardingLogger,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to tail log file: %v", err)
+	}
+
+	var lines []string
+	for line := range t.Lines {
+		if line.Err != nil {
+			continue
+		}
+		lines = append(lines, line.Text)
+		if len(lines) > tailLines {
+			lines = lines[len(lines)-tailLines:]
+		}
+	}
+	t.Stop()
+
+	for _, line := range lines {
+		printLogLine(line)
+	}
+
+	if len(lines) == tailLines {
+		fmt.Fprintf(os.Stderr, "\nShowing last %d lines. Full logs available at: %s\n", tailLines, logsFile)
+		fmt.Fprintf(os.Stderr, "Following new log entries...\n\n")
+	}
+
+	t, err = tail.TailFile(logsFile, tail.Config{
+		Follow:   true,
+		ReOpen:   true,
+		Logger:   tail.DiscardingLogger,
+		Location: &tail.SeekInfo{Offset: 0, Whence: io.SeekEnd},
+	})
+	if err != nil {
+		return fmt.Errorf("failed to tail log file: %v", err)
+	}
+	defer t.Stop()
+
+	for {
+		select {
+		case line := <-t.Lines:
+			if line.Err != nil {
+				continue
+			}
+			printLogLine(line.Text)
+		case <-ctx.Done():
+			return nil
+		}
+	}
+}
+
+func showLogs(logsFile string, tailLines int) error {
+	t, err := tail.TailFile(logsFile, tail.Config{
+		Follow:      false,
+		ReOpen:      false,
+		Logger:      tail.DiscardingLogger,
+		MaxLineSize: 0,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to tail log file: %v", err)
+	}
+	defer t.Stop()
+
+	var lines []string
+	for line := range t.Lines {
+		if line.Err != nil {
+			continue
+		}
+		lines = append(lines, line.Text)
+		if len(lines) > tailLines {
+			lines = lines[len(lines)-tailLines:]
+		}
+	}
+
+	for _, line := range lines {
+		printLogLine(line)
+	}
+
+	if len(lines) == tailLines {
+		fmt.Fprintf(os.Stderr, "\nShowing last %d lines. Full logs available at: %s\n", tailLines, logsFile)
+	}
+
+	return nil
+}
+
+func printLogLine(lineText string) {
+	var data map[string]any
+	if err := json.Unmarshal([]byte(lineText), &data); err != nil {
+		return
+	}
+	msg := data["msg"]
+	level := data["level"]
+	otherData := []any{}
+	keys := []string{}
+	for k := range data {
+		keys = append(keys, k)
+	}
+	slices.Sort(keys)
+	for _, k := range keys {
+		switch k {
+		case "msg", "level", "time":
+			continue
+		case "source":
+			source, ok := data[k].(map[string]any)
+			if !ok {
+				continue
+			}
+			sourceFile := fmt.Sprintf("%s:%d", source["file"], int(source["line"].(float64)))
+			otherData = append(otherData, "source", sourceFile)
+
+		default:
+			otherData = append(otherData, k, data[k])
+		}
+	}
+	log.SetTimeFunction(func(_ time.Time) time.Time {
+		// parse the timestamp from the log line if available
+		t, err := time.Parse(time.RFC3339, data["time"].(string))
+		if err != nil {
+			return time.Now() // fallback to current time if parsing fails
+		}
+		return t
+	})
+	switch level {
+	case "INFO":
+		log.Info(msg, otherData...)
+	case "DEBUG":
+		log.Debug(msg, otherData...)
+	case "ERROR":
+		log.Error(msg, otherData...)
+	case "WARN":
+		log.Warn(msg, otherData...)
+	default:
+		log.Info(msg, otherData...)
+	}
+}

projects/ui/crush/scripts/run-issue-labeler.sh

@@ -0,0 +1,12 @@
+ISSUES=$(gh issue list --state=all --limit=1000 --json "number" -t '{{range .}}{{printf "%.0f\n" .number}}{{end}}')
+PRS=$(gh pr list --state=all --limit=1000 --json "number" -t '{{range .}}{{printf "%.0f\n" .number}}{{end}}')
+
+for issue in $ISSUES; do
+  echo "Dispatching issue-labeler.yml for $issue"
+  gh workflow run issue-labeler.yml -f issue-number="$issue"
+done
+
+for pr in $PRS; do
+  echo "Dispatching issue-labeler.yml for $pr"
+  gh workflow run issue-labeler.yml -f issue-number="$pr"
+done

projects/ui/serena-new/test/solidlsp/zig/test_zig_basic.py

@@ -0,0 +1,343 @@
+"""
+Basic integration tests for Zig language server functionality.
+
+These tests validate symbol finding and navigation capabilities using the Zig Language Server (ZLS).
+Note: ZLS requires files to be open in the editor to find cross-file references (performance optimization).
+"""
+
+import os
+import sys
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+from solidlsp.ls_types import SymbolKind
+
+
+@pytest.mark.zig
+@pytest.mark.skipif(
+    sys.platform == "win32", reason="ZLS is disabled on Windows - cross-file references don't work reliably. Reason unknown."
+)
+class TestZigLanguageServer:
+    """Test Zig language server symbol finding and navigation capabilities.
+
+    NOTE: All tests are skipped on Windows as ZLS is disabled on that platform
+    due to unreliable cross-file reference functionality. Reason unknown.
+    """
+
+    @pytest.mark.parametrize("language_server", [Language.ZIG], indirect=True)
+    def test_find_symbols_in_main(self, language_server: SolidLanguageServer) -> None:
+        """Test finding specific symbols in main.zig."""
+        file_path = os.path.join("src", "main.zig")
+        symbols = language_server.request_document_symbols(file_path)
+
+        assert symbols is not None
+        assert len(symbols) > 0
+
+        # Extract symbol names from the returned structure
+        symbol_list = symbols[0] if isinstance(symbols, tuple) else symbols
+        symbol_names = {sym.get("name") for sym in symbol_list if isinstance(sym, dict)}
+
+        # Verify specific symbols exist
+        assert "main" in symbol_names, "main function not found"
+        assert "greeting" in symbol_names, "greeting function not found"
+
+    @pytest.mark.parametrize("language_server", [Language.ZIG], indirect=True)
+    def test_find_symbols_in_calculator(self, language_server: SolidLanguageServer) -> None:
+        """Test finding Calculator struct and its methods."""
+        file_path = os.path.join("src", "calculator.zig")
+        symbols = language_server.request_document_symbols(file_path)
+
+        assert symbols is not None
+        assert len(symbols) > 0
+
+        symbol_list = symbols[0] if isinstance(symbols, tuple) else symbols
+
+        # Find Calculator struct
+        calculator_symbol = None
+        for sym in symbol_list:
+            if sym.get("name") == "Calculator":
+                calculator_symbol = sym
+                break
+
+        assert calculator_symbol is not None, "Calculator struct not found"
+        # ZLS may use different symbol kinds for structs (14 = Namespace, 5 = Class, 23 = Struct)
+        assert calculator_symbol.get("kind") in [
+            SymbolKind.Class,
+            SymbolKind.Struct,
+            SymbolKind.Namespace,
+            5,
+            14,
+            23,
+        ], "Calculator should be a struct/class/namespace"
+
+        # Check for Calculator methods (init, add, subtract, etc.)
+        # Methods might be in children or at the same level
+        all_symbols = []
+        for sym in symbol_list:
+            all_symbols.append(sym.get("name"))
+            if "children" in sym:
+                for child in sym["children"]:
+                    all_symbols.append(child.get("name"))
+
+        # Verify exact calculator methods exist
+        expected_methods = {"init", "add", "subtract", "multiply", "divide"}
+        found_methods = set(all_symbols) & expected_methods
+        assert found_methods == expected_methods, f"Expected exactly {expected_methods}, found: {found_methods}"
+
+    @pytest.mark.parametrize("language_server", [Language.ZIG], indirect=True)
+    def test_find_symbols_in_math_utils(self, language_server: SolidLanguageServer) -> None:
+        """Test finding functions in math_utils.zig."""
+        file_path = os.path.join("src", "math_utils.zig")
+        symbols = language_server.request_document_symbols(file_path)
+
+        assert symbols is not None
+        assert len(symbols) > 0
+
+        symbol_list = symbols[0] if isinstance(symbols, tuple) else symbols
+        symbol_names = {sym.get("name") for sym in symbol_list if isinstance(sym, dict)}
+
+        # Verify math utility functions exist
+        assert "factorial" in symbol_names, "factorial function not found"
+        assert "isPrime" in symbol_names, "isPrime function not found"
+
+    @pytest.mark.parametrize("language_server", [Language.ZIG], indirect=True)
+    def test_find_references_within_file(self, language_server: SolidLanguageServer) -> None:
+        """Test finding references within the same file."""
+        file_path = os.path.join("src", "calculator.zig")
+        symbols = language_server.request_document_symbols(file_path)
+
+        symbol_list = symbols[0] if isinstance(symbols, tuple) else symbols
+
+        # Find Calculator struct
+        calculator_symbol = None
+        for sym in symbol_list:
+            if sym.get("name") == "Calculator":
+                calculator_symbol = sym
+                break
+
+        assert calculator_symbol is not None, "Calculator struct not found"
+
+        # Find references to Calculator within the same file
+        sel_range = calculator_symbol.get("selectionRange", calculator_symbol.get("range"))
+        assert sel_range is not None, "Calculator symbol has no range information"
+
+        sel_start = sel_range["start"]
+        refs = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+
+        assert refs is not None
+        assert isinstance(refs, list)
+        # ZLS finds references within the same file
+        # Calculator is used in 4 test usages (lines 45, 51, 57, 63)
+        # Note: ZLS may not include the declaration itself as a reference
+        assert len(refs) >= 4, f"Should find at least 4 Calculator references within calculator.zig, found {len(refs)}"
+
+        # Verify we found the test usages
+        ref_lines = sorted([ref["range"]["start"]["line"] for ref in refs])
+        test_lines = [44, 50, 56, 62]  # 0-indexed: tests at lines 45, 51, 57, 63
+        for line in test_lines:
+            assert line in ref_lines, f"Should find Calculator reference at line {line + 1}, found at lines {[l + 1 for l in ref_lines]}"
+
+    @pytest.mark.parametrize("language_server", [Language.ZIG], indirect=True)
+    @pytest.mark.skipif(
+        sys.platform == "win32", reason="ZLS cross-file references don't work reliably on Windows - URI path handling issues"
+    )
+    def test_cross_file_references_with_open_files(self, language_server: SolidLanguageServer) -> None:
+        """
+        Test finding cross-file references with files open.
+
+        ZLS limitation: Cross-file references (textDocument/references) only work when
+        target files are open. This is a performance optimization in ZLS.
+
+        NOTE: Disabled on Windows as cross-file references cannot be made to work reliably
+        due to URI path handling differences between Windows and Unix systems.
+        """
+        import time
+
+        # Open the files that contain references to enable cross-file search
+        with language_server.open_file("build.zig"):
+            with language_server.open_file(os.path.join("src", "main.zig")):
+                with language_server.open_file(os.path.join("src", "calculator.zig")):
+                    # Give ZLS a moment to analyze the open files
+                    time.sleep(1)
+
+                    # Find Calculator struct
+                    symbols = language_server.request_document_symbols(os.path.join("src", "calculator.zig"))
+                    symbol_list = symbols[0] if isinstance(symbols, tuple) else symbols
+
+                    calculator_symbol = None
+                    for sym in symbol_list:
+                        if sym.get("name") == "Calculator":
+                            calculator_symbol = sym
+                            break
+
+                    assert calculator_symbol is not None, "Calculator struct not found"
+
+                    sel_range = calculator_symbol.get("selectionRange", calculator_symbol.get("range"))
+                    assert sel_range is not None, "Calculator symbol has no range information"
+
+                    # Find references to Calculator
+                    sel_start = sel_range["start"]
+                    refs = language_server.request_references(
+                        os.path.join("src", "calculator.zig"), sel_start["line"], sel_start["character"]
+                    )
+
+                    assert refs is not None
+                    assert isinstance(refs, list)
+
+                    # With files open, ZLS should find cross-file references
+                    main_refs = [ref for ref in refs if "main.zig" in ref.get("uri", "")]
+
+                    assert len(main_refs) >= 1, f"Should find at least 1 Calculator reference in main.zig, found {len(main_refs)}"
+
+                    # Verify exact location in main.zig (line 8, 0-indexed: 7)
+                    main_ref_line = main_refs[0]["range"]["start"]["line"]
+                    assert (
+                        main_ref_line == 7
+                    ), f"Calculator reference in main.zig should be at line 8 (0-indexed: 7), found at line {main_ref_line + 1}"
+
+    @pytest.mark.parametrize("language_server", [Language.ZIG], indirect=True)
+    def test_cross_file_references_within_file(self, language_server: SolidLanguageServer) -> None:
+        """
+        Test that ZLS finds references within the same file.
+
+        Note: ZLS is designed to be lightweight and only analyzes files that are explicitly opened.
+        Cross-file references require manually opening the relevant files first.
+        """
+        # Find references to Calculator from calculator.zig
+        file_path = os.path.join("src", "calculator.zig")
+        symbols = language_server.request_document_symbols(file_path)
+        symbol_list = symbols[0] if isinstance(symbols, tuple) else symbols
+
+        calculator_symbol = None
+        for sym in symbol_list:
+            if sym.get("name") == "Calculator":
+                calculator_symbol = sym
+                break
+
+        assert calculator_symbol is not None, "Calculator struct not found"
+
+        sel_range = calculator_symbol.get("selectionRange", calculator_symbol.get("range"))
+        assert sel_range is not None, "Calculator symbol has no range information"
+
+        sel_start = sel_range["start"]
+        refs = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+
+        assert refs is not None
+        assert isinstance(refs, list)
+
+        # ZLS finds references within the same file
+        # Calculator is used in 4 test usages (lines 45, 51, 57, 63)
+        # Note: ZLS may not include the declaration itself as a reference
+        assert len(refs) >= 4, f"Should find at least 4 Calculator references within calculator.zig, found {len(refs)}"
+
+        # Verify we found the test usages
+        ref_lines = sorted([ref["range"]["start"]["line"] for ref in refs])
+        test_lines = [44, 50, 56, 62]  # 0-indexed: tests at lines 45, 51, 57, 63
+        for line in test_lines:
+            assert line in ref_lines, f"Should find Calculator reference at line {line + 1}, found at lines {[l + 1 for l in ref_lines]}"
+
+    @pytest.mark.parametrize("language_server", [Language.ZIG], indirect=True)
+    @pytest.mark.skipif(
+        sys.platform == "win32", reason="ZLS cross-file references don't work reliably on Windows - URI path handling issues"
+    )
+    def test_go_to_definition_cross_file(self, language_server: SolidLanguageServer) -> None:
+        """
+        Test go-to-definition from main.zig to calculator.zig.
+
+        ZLS capability: Go-to-definition (textDocument/definition) works cross-file
+        WITHOUT requiring files to be open.
+
+        NOTE: Disabled on Windows as cross-file references cannot be made to work reliably
+        due to URI path handling differences between Windows and Unix systems.
+        """
+        file_path = os.path.join("src", "main.zig")
+
+        # Line 8: const calc = calculator.Calculator.init();
+        # Test go-to-definition for Calculator
+        definitions = language_server.request_definition(file_path, 7, 25)  # Position of "Calculator"
+
+        assert definitions is not None
+        assert isinstance(definitions, list)
+        assert len(definitions) > 0, "Should find definition of Calculator"
+
+        # Should point to calculator.zig
+        calc_def = definitions[0]
+        assert "calculator.zig" in calc_def.get("uri", ""), "Definition should be in calculator.zig"
+
+    @pytest.mark.parametrize("language_server", [Language.ZIG], indirect=True)
+    @pytest.mark.skipif(
+        sys.platform == "win32", reason="ZLS cross-file references don't work reliably on Windows - URI path handling issues"
+    )
+    def test_cross_file_function_usage(self, language_server: SolidLanguageServer) -> None:
+        """Test finding usage of functions from math_utils in main.zig.
+
+        NOTE: Disabled on Windows as cross-file references cannot be made to work reliably
+        due to URI path handling differences between Windows and Unix systems.
+        """
+        # Line 23 in main.zig: const factorial_result = math_utils.factorial(5);
+        definitions = language_server.request_definition(os.path.join("src", "main.zig"), 22, 40)  # Position of "factorial"
+
+        assert definitions is not None
+        assert isinstance(definitions, list)
+
+        if len(definitions) > 0:
+            # Should find factorial definition in math_utils.zig
+            math_def = [d for d in definitions if "math_utils.zig" in d.get("uri", "")]
+            assert len(math_def) > 0, "Should find factorial definition in math_utils.zig"
+
+    @pytest.mark.parametrize("language_server", [Language.ZIG], indirect=True)
+    def test_verify_cross_file_imports(self, language_server: SolidLanguageServer) -> None:
+        """Verify that our test files have proper cross-file imports."""
+        # Verify main.zig imports
+        main_symbols = language_server.request_document_symbols(os.path.join("src", "main.zig"))
+        assert main_symbols is not None
+        main_list = main_symbols[0] if isinstance(main_symbols, tuple) else main_symbols
+        main_names = {sym.get("name") for sym in main_list if isinstance(sym, dict)}
+
+        # main.zig should have main and greeting functions
+        assert "main" in main_names, "main function should be in main.zig"
+        assert "greeting" in main_names, "greeting function should be in main.zig"
+
+        # Verify calculator.zig exports Calculator
+        calc_symbols = language_server.request_document_symbols(os.path.join("src", "calculator.zig"))
+        assert calc_symbols is not None
+        calc_list = calc_symbols[0] if isinstance(calc_symbols, tuple) else calc_symbols
+        calc_names = {sym.get("name") for sym in calc_list if isinstance(sym, dict)}
+        assert "Calculator" in calc_names, "Calculator struct should be in calculator.zig"
+
+        # Verify math_utils.zig exports functions
+        math_symbols = language_server.request_document_symbols(os.path.join("src", "math_utils.zig"))
+        assert math_symbols is not None
+        math_list = math_symbols[0] if isinstance(math_symbols, tuple) else math_symbols
+        math_names = {sym.get("name") for sym in math_list if isinstance(sym, dict)}
+        assert "factorial" in math_names, "factorial function should be in math_utils.zig"
+        assert "isPrime" in math_names, "isPrime function should be in math_utils.zig"
+
+    @pytest.mark.parametrize("language_server", [Language.ZIG], indirect=True)
+    def test_hover_information(self, language_server: SolidLanguageServer) -> None:
+        """Test hover information for symbols."""
+        file_path = os.path.join("src", "main.zig")
+
+        # Get hover info for the main function
+        hover_info = language_server.request_hover(file_path, 4, 8)  # Position of "main" function
+
+        assert hover_info is not None, "Should provide hover information for main function"
+
+        # Hover info could be a dict with 'contents' or a string
+        if isinstance(hover_info, dict):
+            assert "contents" in hover_info or "value" in hover_info, "Hover should have contents"
+
+    @pytest.mark.parametrize("language_server", [Language.ZIG], indirect=True)
+    def test_full_symbol_tree(self, language_server: SolidLanguageServer) -> None:
+        """Test that full symbol tree is not empty."""
+        symbols = language_server.request_full_symbol_tree()
+
+        assert symbols is not None
+        assert len(symbols) > 0, "Symbol tree should not be empty"
+
+        # The tree should have at least one root node
+        root = symbols[0]
+        assert isinstance(root, dict), "Root should be a dict"
+        assert "name" in root, "Root should have a name"