opencode-qml-lsp 0.1.0

package/.qmllint.ini

@@ -0,0 +1,6 @@
+[General]
+MaxWarnings=-1
+
+[Warnings]
+UnqualifiedAccess=disable
+BlockScopeVarDeclaration=disable

package/.sisyphus/plans/qml-lsp-plugin.md

@@ -0,0 +1,203 @@
+# PLAN: opencode-qml-lsp Plugin
+
+> A plugin + config generator that gives OpenCode first-class QML language server support.
+> Installable via npm, works for any QML/PySide6 project.
+
+---
+
+## Goal
+
+Create `opencode-qml-lsp` — an npm-distributable plugin that:
+1. **Generates** the correct `lsp` config for `opencode.json` (auto-detects qmlls + PySide6 paths)
+2. **Generates** a `.qmlint` config to suppress noisy warnings
+3. **Provides** a custom tool `qml_fix_warnings` for auto-fixing lint issues
+4. **Notifies** via toast when QML issues are detected
+
+**Plugin limitations (OpenCode API constraints):**
+- Plugins **cannot** dynamically inject LSP config at runtime — LSP is set via `opencode.json`
+- Plugins **cannot** intercept/modify `lsp.client.diagnostics` — they can only listen
+- So the plugin works in two modes:
+  - **Setup mode**: generates config files the user adds to their project
+  - **Runtime mode**: provides custom tools + notifications during sessions
+
+---
+
+## Architecture
+
+```
+opencode-qml-lsp/
+├── package.json              # @opencode-ai/plugin dependency
+├── src/
+│   ├── index.js              # Plugin entry point
+│   ├── setup.js              # Config generator (qmlls detection, .qmlint, lsp config)
+│   ├── fix-tool.js           # Custom tool for auto-fixing warnings
+│   └── notify.js             # Diagnostic listener + toast notifications
+└── README.md
+```
+
+---
+
+## Phase 1: Setup Command + Config Generator
+
+**What:** A command that detects the QML environment and generates config files.
+
+**How:**
+- Plugin registers a custom command `/qml-setup`
+- When run, it:
+  1. Searches for `qmlls` binary (PATH, common locations, PySide6 venv)
+  2. Detects PySide6 installation path for QML import resolution
+  3. Scans project for `.qml` files to confirm QML project
+  4. Generates two files:
+     - `.qmlint` — suppresses `unqualified` and `block-scope-var-declaration`
+     - `opencode-qml-lsp.config.json` — the `lsp` block to merge into `opencode.json`
+  5. Prints instructions for the user to merge the config
+
+**Hooks used:**
+- `command.executed` — detect `/qml-setup` command
+- `tui.toast.show` — notify user of setup results
+
+**Generated `.qmlint`:**
+```ini
+[unqualified]
+disable=true
+
+[block-scope-var-declaration]
+disable=true
+```
+
+**Generated `lsp` config snippet:**
+```json
+{
+  "lsp": {
+    "qmlls": {
+      "command": ["/path/to/qmlls", "-E", "-I/path/to/PySide6/Qt/qml"],
+      "extensions": [".qml", ".qrc"]
+    }
+  }
+}
+```
+
+**Success criteria:**
+- User runs `/qml-setup` → gets two config files
+- User merges lsp config into `opencode.json` → qmlls starts working
+- `.qmlint` in place → noise warnings suppressed
+
+---
+
+## Phase 2: Auto-Fix Custom Tool
+
+**What:** Custom tool that the AI can call to fix QML lint warnings.
+
+**How:**
+- Register custom tool via plugin `tool` hook
+- Tool reads file, parses qmllint output, applies fixes
+- Fixes:
+  - `var` → `let`/`const` in JS blocks
+  - Remove unused imports
+  - Qualify unqualified property accesses with `root.` prefix
+- Verifies fix by running `qmllint` on the file
+
+**Tool definition:**
+```js
+qml_fix_warnings: tool({
+  description: "Fix QML lint warnings in a file",
+  args: {
+    filePath: tool.schema.string(),
+    fixTypes: tool.schema.array(tool.schema.enum([
+      "var-to-let",
+      "qualify-access",
+      "remove-unused-imports"
+    ]))
+  },
+  async execute(args, context) {
+    // Read file → parse qmllint output → apply fixes → verify
+  }
+})
+```
+
+**Success criteria:**
+- AI calls `qml_fix_warnings({ filePath: "canvas.qml", fixTypes: ["var-to-let"] })`
+- File is fixed, qmllint confirms clean
+
+---
+
+## Phase 3: Diagnostic Notifications
+
+**What:** Listen to `lsp.client.diagnostics` events and show toast summaries.
+
+**How:**
+- Hook `lsp.client.diagnostics` — listen for QML file diagnostics
+- When a `.qml` file has diagnostics, show toast:
+  - `"canvas.qml: 3 warnings, 0 errors"`
+- Hook `file.edited` — when a `.qml` file is saved, trigger re-lint via bash
+
+**Hooks used:**
+- `lsp.client.diagnostics` — listen for diagnostic events
+- `file.edited` — trigger re-lint on save
+- `tui.toast.show` — show summary notifications
+
+**Success criteria:**
+- Open a QML file with issues → toast shows count
+- Fix a QML file → toast updates
+
+---
+
+## Phase 4: npm Package + Distribution
+
+**What:** Publish to npm so anyone can install.
+
+**How:**
+- `package.json` with name `opencode-qml-lsp`
+- `@opencode-ai/plugin` as dependency
+- Entry point exports plugin function
+- README with install instructions
+
+**Install for users:**
+```json
+// opencode.json
+{
+  "plugin": ["opencode-qml-lsp"]
+}
+```
+
+Then run `/qml-setup` in any QML project.
+
+---
+
+## Implementation Order
+
+1. **Phase 1** — Setup command + config generator (foundation, testable immediately)
+2. **Phase 2** — Auto-fix custom tool (highest value feature)
+3. **Phase 3** — Diagnostic notifications (polish)
+4. **Phase 4** — npm packaging (distribution)
+
+---
+
+## Files to Create
+
+| File | Purpose |
+|---|---|
+| `plugins/qml-lsp/package.json` | Plugin package definition |
+| `plugins/qml-lsp/src/index.js` | Plugin entry, hooks registration |
+| `plugins/qml-lsp/src/setup.js` | qmlls detection + config generation |
+| `plugins/qml-lsp/src/fix-tool.js` | Custom auto-fix tool |
+| `plugins/qml-lsp/src/notify.js` | Diagnostic listener + toast |
+| `plugins/qml-lsp/README.md` | Usage docs |
+
+---
+
+## Testing Strategy
+
+1. **Local testing** — place in `.opencode/plugins/` during development
+2. **Test project** — use `my_canvas_app/views/canvas.qml` (374 warnings → ~5 after .qmlint)
+3. **Verify setup** — run `/qml-setup`, check generated files
+4. **Verify fix tool** — call `qml_fix_warnings`, check lsp_diagnostics
+5. **Distribution test** — `npm link` to simulate npm install
+
+---
+
+## Risks
+
+- **qmlls not on PATH** — setup command searches common locations: `~/.local/share/qmlls/`, PySide6 venv, system PATH
+- **PySide6 import paths vary** — setup auto-detects by finding `python -c "import PySide6; print(PySide6.__path__)"` 
+- **Custom command registration** — OpenCode plugins register commands via `tui.executeCommand`, not a dedicated command hook. May need to use a different approach (e.g., detect user typing `/qml-setup` in prompt)

package/README.md

@@ -0,0 +1,94 @@
+# opencode-qml-lsp
+
+QML language server support for [OpenCode](https://opencode.ai).
+
+## Features
+
+- **Auto-detect qmlls** — finds qmlls binary and PySide6 QML import paths
+- **Generate .qmlint** — suppresses noisy warnings (unqualified access, block-scope-var)
+- **Custom LSP config** — generates the correct `lsp` block for your `opencode.json`
+- **Auto-fix tool** — `qml_fix_warnings` fixes common lint issues automatically
+
+## Installation
+
+### 1. Add to your `opencode.json`
+
+```json
+{
+  "plugin": ["opencode-qml-lsp"]
+}
+```
+
+### 2. Run setup in your QML project
+
+Open OpenCode in your QML project directory and ask the AI to run:
+
+```
+run qml_setup
+```
+
+Or invoke the `qml_setup` tool directly. This generates two files:
+- `.qmlint` — suppresses noisy warnings
+- `opencode-qml-lsp.config.json` — the `lsp` config block to merge into `opencode.json`
+
+### 3. Merge the LSP config
+
+Copy the `lsp` block from `opencode-qml-lsp.config.json` into your `opencode.json`:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "lsp": {
+    "qmlls": {
+      "command": ["/path/to/qmlls", "-E", "-I/path/to/PySide6/Qt/qml"],
+      "extensions": [".qml", ".qrc"]
+    }
+  }
+}
+```
+
+## Custom Tools
+
+### `qml_setup`
+
+Detects `qmlls`, finds PySide6 QML import paths, and generates `.qmlint` + LSP config. No arguments needed.
+
+### `qml_fix_warnings`
+
+Fixes QML lint warnings in a file:
+
+```
+qml_fix_warnings({
+  filePath: "my_canvas_app/views/canvas.qml",
+  fixTypes: ["var-to-let", "remove-unused-imports", "qualify-access"]
+})
+```
+
+### Fix Types
+
+| Fix Type | What it does |
+|---|---|
+| `var-to-let` | Replaces `var` with `let` in JS blocks |
+| `remove-unused-imports` | Removes unused `import` statements |
+| `qualify-access` | Adds `root.` prefix to unqualified property accesses |
+
+## Development
+
+```bash
+# Clone
+git clone https://github.com/your-username/opencode-qml-lsp.git
+cd opencode-qml-lsp
+
+# Install dependencies
+npm install
+
+# Link locally for testing
+ln -s $(pwd) ~/.config/opencode/plugins/opencode-qml-lsp
+
+# Or use npm link
+npm link
+```
+
+## License
+
+MIT

package/opencode.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "model": "opencode/qwen3.6-plus-free",
+  "plugin": [
+    "oh-my-openagent@latest"
+  ]
+}

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "opencode-qml-lsp",
+  "version": "0.1.0",
+  "description": "QML language server support for OpenCode — auto-detect qmlls, filter diagnostics, auto-fix warnings",
+  "main": "src/index.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"No tests yet\""
+  },
+  "keywords": ["opencode", "qml", "qmlls", "pyside6", "lsp", "plugin"],
+  "license": "MIT",
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.0.0"
+  }
+}

package/src/fix-tool.js

@@ -0,0 +1,99 @@
+import { tool } from "@opencode-ai/plugin";
+import { readFileSync, writeFileSync } from "fs";
+
+export function QmlFixTool({ client, $, directory }) {
+  async function fixVarToLet(content) {
+    return content.replace(
+      /\bvar\s+(\w+)/g,
+      (match, name) => {
+        return `let ${name}`;
+      }
+    );
+  }
+
+  async function fixRemoveUnusedImports(content) {
+    const lines = content.split("\n");
+    const importLines = [];
+    const usedModules = new Set();
+
+    lines.forEach((line, i) => {
+      const importMatch = line.match(/^import\s+(\S+)/);
+      if (importMatch) {
+        importLines.push({ index: i, module: importMatch[1] });
+      }
+    });
+
+    for (const { module } of importLines) {
+      const cleanModule = module.replace(/^["']|["']$/g, "");
+      if (cleanModule === "QtQuick") continue;
+      const pattern = new RegExp(`\\b${cleanModule.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`);
+      const contentWithoutImports = lines.filter((_, i) => !importLines.some(imp => imp.index === i)).join("\n");
+      if (pattern.test(contentWithoutImports)) {
+        usedModules.add(cleanModule);
+      }
+    }
+
+    const unusedImports = importLines.filter(({ module }) => {
+      const cleanModule = module.replace(/^["']|["']$/g, "");
+      return cleanModule !== "QtQuick" && !usedModules.has(cleanModule);
+    });
+
+    if (unusedImports.length === 0) return content;
+
+    const removeIndices = new Set(unusedImports.map(imp => imp.index));
+    return lines.filter((_, i) => !removeIndices.has(i)).join("\n");
+  }
+
+  async function fixQualifyAccess(content, rootId = "root") {
+    const propertiesToQualify = [
+      "zoomLevel", "panX", "panY", "artboardWidth", "artboardHeight",
+      "isSpacePressed", "isMultiDragging", "multiDragLastX", "multiDragLastY",
+      "multiDragInitiatorId"
+    ];
+
+    let result = content;
+    for (const prop of propertiesToQualify) {
+      const pattern = new RegExp(`(?<!\\.)\\b${prop}\\b(?!\\s*:)(?!\\.)`, "g");
+      result = result.replace(pattern, `${rootId}.${prop}`);
+    }
+    return result;
+  }
+
+  const fixers = {
+    "var-to-let": fixVarToLet,
+    "remove-unused-imports": fixRemoveUnusedImports,
+    "qualify-access": fixQualifyAccess,
+  };
+
+  const qmlFixTool = tool({
+    description: "Fix QML lint warnings in a file. Supports: var-to-let, remove-unused-imports, qualify-access",
+    args: {
+      filePath: tool.schema.string().describe("Path to the QML file to fix"),
+      fixTypes: tool.schema.array(tool.schema.enum(["var-to-let", "remove-unused-imports", "qualify-access"])).describe("Types of fixes to apply"),
+    },
+    async execute({ filePath, fixTypes }) {
+      try {
+        const content = readFileSync(filePath, "utf-8");
+        let result = content;
+
+        for (const fixType of fixTypes) {
+          const fixer = fixers[fixType];
+          if (fixer) {
+            result = await fixer(result);
+          }
+        }
+
+        if (result === content) {
+          return `No changes needed for ${filePath}.`;
+        }
+
+        writeFileSync(filePath, result);
+        return `Applied fixes to ${filePath}: ${fixTypes.join(", ")}`;
+      } catch (error) {
+        return `Error fixing file ${filePath}: ${error.message}`;
+      }
+    },
+  });
+
+  return { tool: qmlFixTool };
+}

package/src/index.js

@@ -0,0 +1,44 @@
+import { tool } from "@opencode-ai/plugin";
+import { QmlLspSetup } from "./setup.js";
+import { QmlFixTool } from "./fix-tool.js";
+
+/**
+ * opencode-qml-lsp — QML language server support for OpenCode
+ * @type {import('@opencode-ai/plugin').Plugin}
+ */
+export const QmlLspPlugin = async (ctx) => {
+  const { project, client, $, directory } = ctx;
+
+  const setup = QmlLspSetup({ client, $, directory });
+  const fixTool = QmlFixTool({ client, $, directory });
+
+  return {
+    tool: {
+      qml_setup: tool({
+        description: "Run QML project setup: detect qmlls, generate .qmlint and LSP config for the current project",
+        args: {},
+        async execute(_args, context) {
+          const result = await setup.run();
+          if (!result.success) {
+            return `Setup failed: ${result.message}`;
+          }
+          return [
+            `QML setup complete!`,
+            ``,
+            `Found: ${result.qmllsPath}`,
+            `PySide6 QML import: ${result.qmlImportPath || "not found (using defaults)"}`,
+            `.qml files detected: ${result.qmlFileCount}`,
+            ``,
+            `Generated files:`,
+            result.generatedFiles.map(f => `  - ${f}`).join("\n"),
+            ``,
+            `Next step: Merge the "lsp" block from opencode-qml-lsp.config.json into your opencode.json`,
+          ].join("\n");
+        },
+      }),
+      qml_fix_warnings: fixTool.tool,
+    },
+  };
+};
+
+export default QmlLspPlugin;

package/src/setup.js

@@ -0,0 +1,108 @@
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { execSync } from "child_process";
+
+const QMLLINT_CONTENT = `[General]
+MaxWarnings=-1
+
+[Warnings]
+UnqualifiedAccess=disable
+BlockScopeVarDeclaration=disable
+`;
+
+const COMMON_QMLLS_PATHS = [
+  "~/.local/share/qmlls/files/qmlls",
+  "/usr/bin/qmlls",
+  "/usr/local/bin/qmlls",
+];
+
+export function QmlLspSetup({ client, $$, directory }) {
+  function findQmlls() {
+    for (const path of COMMON_QMLLS_PATHS) {
+      const expanded = path.replace("~", process.env.HOME || "");
+      if (existsSync(expanded)) return expanded;
+    }
+
+    try {
+      const stdout = execSync("which qmlls", { encoding: "utf-8" }).trim();
+      if (stdout) return stdout;
+    } catch {}
+
+    try {
+      const stdout = execSync("python3 -c \"import PySide6; import os; print(os.path.join(os.path.dirname(PySide6.__file__), 'Qt', 'libexec', 'qmlls'))\"", { encoding: "utf-8" }).trim();
+      if (existsSync(stdout)) return stdout;
+    } catch {}
+
+    return null;
+  }
+
+  function findPySide6QmlPath() {
+    try {
+      const stdout = execSync("python3 -c \"import PySide6; import os; print(os.path.join(os.path.dirname(PySide6.__file__), 'Qt', 'qml'))\"", { encoding: "utf-8" }).trim();
+      if (existsSync(stdout)) return stdout;
+    } catch {}
+    return null;
+  }
+
+  function findQmlFiles() {
+    try {
+      const stdout = execSync(`find ${directory} -name "*.qml" -not -path "*/node_modules/*" -not -path "*/.git/*"`, { encoding: "utf-8" });
+      return stdout.trim().split("\n").filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+
+  function generateQmlint() {
+    return QMLLINT_CONTENT;
+  }
+
+  function generateLspConfig(qmllsPath, qmlImportPath) {
+    const importArgs = [];
+    if (qmlImportPath) importArgs.push(`-I${qmlImportPath}`);
+    importArgs.push(`-I${directory}`);
+
+    return {
+      lsp: {
+        qmlls: {
+          command: [qmllsPath, "-E", ...importArgs],
+          extensions: [".qml", ".qrc"],
+        },
+      },
+    };
+  }
+
+  function run() {
+    const qmlFiles = findQmlFiles();
+    if (qmlFiles.length === 0) {
+      return { success: false, message: "No .qml files found in this project." };
+    }
+
+    const qmllsPath = findQmlls();
+    if (!qmllsPath) {
+      return { success: false, message: "qmlls not found. Install PySide6 or qmlls first." };
+    }
+
+    const qmlImportPath = findPySide6QmlPath();
+
+    const qmllintIniPath = join(directory, ".qmllint.ini");
+    if (!existsSync(qmllintIniPath)) {
+      writeFileSync(qmllintIniPath, generateQmlint());
+    }
+
+    const lspConfig = generateLspConfig(qmllsPath, qmlImportPath);
+    const configPath = join(directory, "opencode-qml-lsp.config.json");
+    writeFileSync(configPath, JSON.stringify(lspConfig, null, 2));
+
+    return {
+      success: true,
+      qmllsPath,
+      qmlImportPath,
+      qmlFileCount: qmlFiles.length,
+      generatedFiles: [".qmllint.ini", "opencode-qml-lsp.config.json"],
+      instructions: `Merge the "lsp" block from opencode-qml-lsp.config.json into your opencode.json`,
+    };
+  }
+
+  return { run, findQmlls, findQmlFiles };
+}