@ken-jo/agent-connector 0.4.0 → 0.4.1

package/dist/{qwen-code-WQBKRPWJ.js → qwen-code-G4CXKUHR.js}

@@ -1,4 +1,17 @@
 #!/usr/bin/env node
+import {
+  addLedgerOwner,
+  createLedgerEntry,
+  describeJsonValue,
+  dropLedgerEntry,
+  findLedgerEntry,
+  hashJsonValue,
+  jsonDeepEquals,
+  ledgerEntriesOwnedBy,
+  loadConfigPatchLedger,
+  removeLedgerOwner,
+  saveConfigPatchLedger
+} from "./chunk-FAHIMJRU.js";
 import {
   writeTomlString
 } from "./chunk-OPXAP3AC.js";
@@ -7,16 +20,18 @@ import {
 } from "./chunk-DBQMX75U.js";
 import {
   BaseAdapter
-} from "./chunk-IW77FFNX.js";
+} from "./chunk-CPLK7GTE.js";
 import {
   renderSkillMd
 } from "./chunk-7L6ITC4T.js";
 import {
   buildHomeBinHookCommand,
+  buildHomeBinStatuslineCommand,
   buildServeWrapperCommand,
   isHomeBinHookCommand,
+  isHomeBinStatuslineCommand,
   shouldWrapForTelemetry
-} from "./chunk-BXGFUENQ.js";
+} from "./chunk-I5MLE6S7.js";
 import "./chunk-N6HH7K6P.js";
 import "./chunk-TRQKHP7D.js";
 
@@ -26,6 +41,7 @@ import { homedir } from "os";
 import { join } from "path";
 var HOST = "qwen-code";
 var MCP_ROOT_KEY = "mcpServers";
+var STATUSLINE_KEY = "ui.statusLine";
 var QwenCodeAdapter = class extends BaseAdapter {
   id = HOST;
   name = "Qwen CLI";
@@ -39,6 +55,10 @@ var QwenCodeAdapter = class extends BaseAdapter {
     preToolUse: true,
     postToolUse: true,
     preCompact: true,
+    // Qwen fires PostCompact natively (observe-only — "not in the decision mode
+    // supported events list"; QwenLM/qwen-code docs/users/features/hooks.md
+    // "#### PostCompact", trigger + compact_summary payload).
+    postCompact: true,
     sessionStart: true,
     sessionEnd: true,
     userPromptSubmit: true,
@@ -63,7 +83,22 @@ var QwenCodeAdapter = class extends BaseAdapter {
     // Ground truth: kilo-pi-ground-truth.md § "Already-known skills gaps".
     supportsCommands: true,
     supportsSkills: true,
-    supportsSubagents: true
+    supportsSubagents: true,
+    // Statusline surface: qwen-code is the 2nd v1 host (after claude-code).
+    // installStatusline wires settings.json `ui.statusLine` = {type:"command",
+    // command:<home-bin statusline cmd>} through the SAME refcounted ownership
+    // ledger as configPatch (never clobbers a ui.statusLine agent-connector does
+    // not own). The key is NESTED here (`ui.statusLine`), unlike claude-code's
+    // top-level `statusLine`. Confirmed config key + stdin payload against the
+    // qwen-code status-line docs (shipped v0.14.3, PR #2923).
+    supportsStatusline: true,
+    // Native passthrough: Qwen's 16-event surface includes 3 host-specific events
+    // with NO canonical HookEventName analog — TodoCreated / TodoCompleted /
+    // StopFailure (QwenLM/qwen-code docs/users/features/hooks.md). A connector
+    // reaches them via platforms["qwen-code"].nativeHooks; installHooks files the
+    // PascalCase event key VERBATIM into settings.json hooks, and the generic
+    // uninstall reverses it.
+    supportsNativeHooks: true
   };
   // ── Detection ────────────────────────────────────────────────────────────
   detectInstalled(projectDir) {
@@ -198,18 +233,26 @@ var QwenCodeAdapter = class extends BaseAdapter {
   // ── Hook install / uninstall ─────────────────────────────────────────────
   installHooks(ctx) {
     const { connector } = ctx;
-    if (connector.platforms[HOST]?.hooks === false) {
-      return [{ platform: this.id, action: "skip", detail: "hooks disabled for qwen-code" }];
-    }
-    if (connector.hookEvents.length === 0) {
-      return [{ platform: this.id, action: "skip", detail: "connector declares no hooks" }];
+    const override = connector.platforms[HOST];
+    const hooksDisabled = override?.hooks === false;
+    const normalizedEvents = hooksDisabled ? [] : connector.hookEvents;
+    const nativeHooks = override?.nativeHooks ?? {};
+    const nativeEvents = Object.keys(nativeHooks);
+    if (normalizedEvents.length === 0 && nativeEvents.length === 0) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          detail: hooksDisabled ? "hooks disabled for qwen-code" : "connector declares no hooks"
+        }
+      ];
     }
     const settingsPath = this.getHookConfigPath(ctx);
     const settings = this.readJson(settingsPath) ?? {};
     const hooks = settings.hooks ??= {};
     const changes = [];
     let mutated = false;
-    for (const event of connector.hookEvents) {
+    for (const event of normalizedEvents) {
       const command = buildHomeBinHookCommand(ctx.homeBinPath, HOST, event, connector.id);
       const matcher = connector.hooks[event]?.matcher ?? "";
       const entry = {
@@ -246,6 +289,32 @@ var QwenCodeAdapter = class extends BaseAdapter {
       }
       mutated = true;
     }
+    for (const nativeEvent of nativeEvents) {
+      const command = buildHomeBinHookCommand(ctx.homeBinPath, HOST, nativeEvent, connector.id);
+      const entry = {
+        matcher: nativeHooks[nativeEvent]?.matcher ?? "",
+        hooks: [{ type: "command", command }]
+      };
+      const bucket = hooks[nativeEvent] ??= [];
+      const existingIdx = bucket.findIndex((e) => e.hooks?.[0]?.command === command);
+      if (existingIdx >= 0) {
+        if (JSON.stringify(bucket[existingIdx]) === JSON.stringify(entry)) {
+          changes.push({
+            platform: this.id,
+            action: "skip",
+            path: settingsPath,
+            detail: `hooks.${nativeEvent} (native) already registered`
+          });
+          continue;
+        }
+        bucket[existingIdx] = entry;
+        changes.push({ platform: this.id, action: "update", path: settingsPath, detail: `hooks.${nativeEvent} (native)` });
+      } else {
+        bucket.push(entry);
+        changes.push({ platform: this.id, action: "create", path: settingsPath, detail: `hooks.${nativeEvent} (native)` });
+      }
+      mutated = true;
+    }
     if (mutated) this.writeJson(settingsPath, settings, ctx.dryRun);
     return changes;
   }
@@ -307,6 +376,282 @@ var QwenCodeAdapter = class extends BaseAdapter {
   isOurCommand(command, ctx) {
     return isHomeBinHookCommand(command, ctx.homeBinPath, ctx.connector.id);
   }
+  // ── Statusline surface (a HUD/status line) ────────────────────────────────
+  // Wires settings.json `ui.statusLine` = { type:"command", command:<home-bin
+  // statusline cmd> } through the SAME refcounted ownership ledger as configPatch
+  // (the ledger primitives are surface-agnostic). qwen-code does NOT advertise
+  // supportsConfigPatch, so — unlike claude-code, which routes the statusline
+  // through its private applyConfigPatches loop — this adapter performs the nested
+  // set-if-absent write directly with the exported ledger primitives. Semantics
+  // are identical: never clobber a ui.statusLine agent-connector does not own
+  // (skip-warn), record prior state + owner (refcounted across connectors),
+  // reversible by uninstallStatusline (last-owner-verified delete). The key is
+  // NESTED (`ui.statusLine`), so we own the `ui.statusLine` leaf — if the user
+  // already has it, we skip-warn and never touch their value.
+  //
+  // The home-bin command makes Qwen exec
+  // `<homeBin> statusline qwen-code --connector <id>` for every status refresh,
+  // which re-imports the connector module and renders the line (runtime/
+  // statusline-entrypoint). No telemetry in v1.
+  /** The statusLine config object value agent-connector writes at `ui.statusLine`. */
+  statuslineValue(ctx) {
+    const command = buildHomeBinStatuslineCommand(ctx.homeBinPath, HOST, ctx.connector.id);
+    return { type: "command", command };
+  }
+  installStatusline(ctx) {
+    const { connector } = ctx;
+    if (connector.statusline == null) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no statusline" }];
+    }
+    if (connector.platforms[HOST]?.statusline === false) {
+      return [{ platform: this.id, action: "skip", detail: "statusline disabled for qwen-code" }];
+    }
+    const filePath = this.getServerConfigPath(ctx);
+    if (this.isPresentButUnparseable(filePath)) {
+      return [
+        {
+          platform: this.id,
+          action: "warn",
+          path: filePath,
+          detail: `existing ${filePath} is not parseable; statusline left unapplied (back it up / fix it, then re-run)`
+        }
+      ];
+    }
+    const settings = this.readJson(filePath) ?? {};
+    if (typeof settings !== "object" || Array.isArray(settings)) {
+      return [
+        {
+          platform: this.id,
+          action: "warn",
+          path: filePath,
+          detail: `existing ${filePath} is not a JSON object; statusline left unapplied`
+        }
+      ];
+    }
+    const ledger = loadConfigPatchLedger(ctx.dataRoot);
+    const desired = this.statuslineValue(ctx);
+    const segments = STATUSLINE_KEY.split(".");
+    const leaf = readJsonLeaf(settings, segments);
+    const entry = findLedgerEntry(ledger, HOST, filePath, STATUSLINE_KEY);
+    const changes = [];
+    if (leaf.kind === "blocked") {
+      return [
+        {
+          platform: this.id,
+          action: "warn",
+          path: filePath,
+          detail: `statusline ${STATUSLINE_KEY} skipped: "${leaf.atPath}" exists but is not an object \u2014 set ${STATUSLINE_KEY} manually if wanted`
+        }
+      ];
+    }
+    if (leaf.kind === "absent") {
+      writeJsonLeaf(settings, segments, desired);
+      this.writeJson(filePath, settings, ctx.dryRun);
+      if (entry) {
+        entry.writtenValue = desired;
+        entry.writtenValueHash = hashJsonValue(desired);
+        addLedgerOwner(entry, connector.id, connector.version);
+      } else {
+        createLedgerEntry(ledger, {
+          platform: HOST,
+          file: filePath,
+          key: STATUSLINE_KEY,
+          value: desired,
+          connectorId: connector.id,
+          connectorVersion: connector.version
+        });
+      }
+      if (!ctx.dryRun) saveConfigPatchLedger(ctx.dataRoot, ledger);
+      changes.push({
+        platform: this.id,
+        action: "create",
+        path: filePath,
+        detail: `statusline ${STATUSLINE_KEY}: <absent> \u2192 ${describeJsonValue(desired)}`
+      });
+      return changes;
+    }
+    if (!entry) {
+      return [
+        {
+          platform: this.id,
+          action: "warn",
+          path: filePath,
+          detail: `statusline ${STATUSLINE_KEY} skipped: already set to ${describeJsonValue(leaf.value)} (not created by agent-connector) \u2014 left untouched`
+        }
+      ];
+    }
+    if (!jsonDeepEquals(leaf.value, entry.writtenValue)) {
+      return [
+        {
+          platform: this.id,
+          action: "warn",
+          path: filePath,
+          detail: `statusline ${STATUSLINE_KEY}: value changed since install (current ${describeJsonValue(leaf.value)}, wrote ${describeJsonValue(entry.writtenValue)}); leaving in place`
+        }
+      ];
+    }
+    if (jsonDeepEquals(desired, leaf.value)) {
+      const owners = entry.owners.map((o) => o.connectorId);
+      if (addLedgerOwner(entry, connector.id, connector.version)) {
+        if (!ctx.dryRun) saveConfigPatchLedger(ctx.dataRoot, ledger);
+        return [
+          {
+            platform: this.id,
+            action: "skip",
+            path: filePath,
+            detail: `statusline ${STATUSLINE_KEY} already installed; registered as co-owner (co-owned with ${owners.join(", ")})`
+          }
+        ];
+      }
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          path: filePath,
+          detail: `statusline ${STATUSLINE_KEY} already installed`
+        }
+      ];
+    }
+    return [
+      {
+        platform: this.id,
+        action: "warn",
+        path: filePath,
+        detail: `statusline ${STATUSLINE_KEY} skipped: already owned by ${entry.owners.map((o) => o.connectorId).join(", ")} with a different value \u2014 left untouched`
+      }
+    ];
+  }
+  uninstallStatusline(ctx) {
+    const ledger = loadConfigPatchLedger(ctx.dataRoot);
+    const owned = ledgerEntriesOwnedBy(ledger, HOST, ctx.connector.id).filter(
+      (e) => e.key === STATUSLINE_KEY
+    );
+    if (owned.length === 0) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          detail: "statusline: no ownership recorded; left untouched"
+        }
+      ];
+    }
+    const changes = [];
+    let ledgerMutated = false;
+    const byFile = /* @__PURE__ */ new Map();
+    for (const entry of owned) {
+      const bucket = byFile.get(entry.file) ?? [];
+      bucket.push(entry);
+      byFile.set(entry.file, bucket);
+    }
+    for (const [filePath, entries] of byFile) {
+      const unparseable = this.isPresentButUnparseable(filePath);
+      const settings = unparseable ? null : this.readJson(filePath);
+      let fileMutated = false;
+      for (const entry of entries) {
+        const { lastOwner } = removeLedgerOwner(entry, ctx.connector.id);
+        ledgerMutated = true;
+        if (!lastOwner) {
+          changes.push({
+            platform: this.id,
+            action: "skip",
+            path: filePath,
+            detail: `statusline ${entry.key} retained: still owned by ${entry.owners.map((o) => o.connectorId).join(", ")}`
+          });
+          continue;
+        }
+        dropLedgerEntry(ledger, entry);
+        if (unparseable) {
+          changes.push({
+            platform: this.id,
+            action: "warn",
+            path: filePath,
+            detail: `statusline ${entry.key}: ${filePath} is not parseable; key left in place (ownership released)`
+          });
+          continue;
+        }
+        if (!settings || typeof settings !== "object" || Array.isArray(settings)) {
+          changes.push({
+            platform: this.id,
+            action: "skip",
+            path: filePath,
+            detail: `statusline ${entry.key} already absent (no settings file); ownership record dropped`
+          });
+          continue;
+        }
+        const leaf = readJsonLeaf(settings, entry.key.split("."));
+        if (leaf.kind !== "present") {
+          changes.push({
+            platform: this.id,
+            action: "skip",
+            path: filePath,
+            detail: `statusline ${entry.key} already absent; ownership record dropped`
+          });
+          continue;
+        }
+        if (entry.prior?.present !== false || !jsonDeepEquals(leaf.value, entry.writtenValue)) {
+          changes.push({
+            platform: this.id,
+            action: "warn",
+            path: filePath,
+            detail: `statusline ${entry.key}: value changed since install (current ${describeJsonValue(leaf.value)}, wrote ${describeJsonValue(entry.writtenValue)}); left in place`
+          });
+          continue;
+        }
+        deleteJsonLeaf(settings, entry.key.split("."));
+        fileMutated = true;
+        changes.push({
+          platform: this.id,
+          action: "remove",
+          path: filePath,
+          detail: `statusline ${entry.key} removed (was ${describeJsonValue(entry.writtenValue)})`
+        });
+      }
+      if (fileMutated && settings) this.writeJson(filePath, settings, ctx.dryRun);
+    }
+    if (ledgerMutated && !ctx.dryRun) saveConfigPatchLedger(ctx.dataRoot, ledger);
+    return changes;
+  }
+  /**
+   * Parse Qwen's statusLine stdin JSON into the normalized
+   * {@link StatuslineContext}. Qwen pipes a JSON object to the statusLine command
+   * on stdin (model, context_window, workspace, git, …); fields the payload omits
+   * stay undefined. `raw` keeps the verbatim payload (incl. version/git/metrics/
+   * vim). NOTE: Qwen has NO cost analog (no cost field in the payload), so
+   * `ctx.cost` is intentionally left undefined. Sources: qwen-code status-line
+   * docs, QwenLM/qwen-code settings.md.
+   */
+  parseStatusInput(raw) {
+    const input = raw ?? {};
+    const ctx = {
+      host: HOST,
+      capabilities: this.capabilities,
+      raw
+    };
+    if (typeof input.session_id === "string" && input.session_id !== "") {
+      ctx.sessionId = input.session_id;
+    }
+    if (typeof input.workspace?.current_dir === "string") {
+      ctx.cwd = input.workspace.current_dir;
+    }
+    if (typeof input.model?.display_name === "string") {
+      ctx.model = { displayName: input.model.display_name };
+    }
+    const cw = input.context_window;
+    if (cw) {
+      const context = {};
+      if (typeof cw.context_window_size === "number") context.maxTokens = cw.context_window_size;
+      if (typeof cw.current_usage === "number") context.usedTokens = cw.current_usage;
+      if (typeof cw.used_percentage === "number") context.percent = cw.used_percentage;
+      if (context.usedTokens !== void 0 || context.maxTokens !== void 0 || context.percent !== void 0) {
+        ctx.context = context;
+      }
+    }
+    return ctx;
+  }
+  /** Format the rendered status line into Qwen's native reply: stdout = line, exit 0. */
+  formatStatusOutput(rendered) {
+    return { exitCode: 0, stdout: rendered };
+  }
   // ── Content surfaces: commands / subagents ───────────────────────────────
   // CONTENT-ONLY: pure native-file writers under <qwenDir>/{commands,agents}. No
   // runtime dispatch, no home-bin pointer, no telemetry wrap. Each method is
@@ -513,6 +858,32 @@ var QwenCodeAdapter = class extends BaseAdapter {
         check: () => existsSync(p) ? { status: "OK", detail: p } : { status: "FAIL", detail: `not found: ${p}` }
       });
     }
+    const statuslineLedgerOwned = ledgerEntriesOwnedBy(
+      loadConfigPatchLedger(ctx.dataRoot),
+      HOST,
+      connectorId
+    ).some((e) => e.key === STATUSLINE_KEY);
+    if ((ctx.connector.statusline != null || statuslineLedgerOwned) && ctx.connector.platforms[HOST]?.statusline !== false) {
+      checks.push({
+        name: `${this.name}: statusline wired`,
+        check: () => {
+          const settings = this.readJson(
+            settingsPath
+          );
+          const command = settings?.ui?.statusLine?.command;
+          if (command === void 0) {
+            return { status: "FAIL", detail: `ui.statusLine not set in ${settingsPath}` };
+          }
+          if (typeof command === "string" && isHomeBinStatuslineCommand(command, homeBin, connectorId)) {
+            return { status: "OK", detail: "ui.statusLine command present" };
+          }
+          return {
+            status: "FAIL",
+            detail: `ui.statusLine in ${settingsPath} is not agent-connector's (left untouched)`
+          };
+        }
+      });
+    }
     return checks;
   }
   // ── Runtime: parse Qwen stdin JSON → normalized event ────────────────────
@@ -574,6 +945,13 @@ var QwenCodeAdapter = class extends BaseAdapter {
         };
         return ev;
       }
+      case "PostCompact": {
+        const ev = {
+          ...base,
+          ...input.trigger === "auto" || input.trigger === "manual" ? { trigger: input.trigger } : {}
+        };
+        return ev;
+      }
       case "Stop": {
         const ev = {
           ...base,
@@ -713,6 +1091,44 @@ var QwenCodeAdapter = class extends BaseAdapter {
     return { exitCode: 0, stdout: JSON.stringify(payload) };
   }
 };
+function readJsonLeaf(root, segments) {
+  let node = root;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const next = node[segments[i]];
+    if (next === void 0) return { kind: "absent" };
+    if (next === null || typeof next !== "object" || Array.isArray(next)) {
+      return { kind: "blocked", atPath: segments.slice(0, i + 1).join(".") };
+    }
+    node = next;
+  }
+  const leaf = node[segments[segments.length - 1]];
+  if (leaf === void 0) return { kind: "absent" };
+  return { kind: "present", value: leaf };
+}
+function writeJsonLeaf(root, segments, value) {
+  let node = root;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const seg = segments[i];
+    const next = node[seg];
+    if (next === void 0) {
+      const created = {};
+      node[seg] = created;
+      node = created;
+    } else {
+      node = next;
+    }
+  }
+  node[segments[segments.length - 1]] = value;
+}
+function deleteJsonLeaf(root, segments) {
+  let node = root;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const next = node[segments[i]];
+    if (next === null || typeof next !== "object" || Array.isArray(next)) return;
+    node = next;
+  }
+  delete node[segments[segments.length - 1]];
+}
 function extractSessionId(input) {
   if (typeof input.session_id === "string" && input.session_id !== "") {
     return input.session_id;
@@ -751,4 +1167,4 @@ export {
   adapter,
   qwen_code_default as default
 };
-//# sourceMappingURL=qwen-code-WQBKRPWJ.js.map
+//# sourceMappingURL=qwen-code-G4CXKUHR.js.map