@k-leumas/queque-cli 0.6.1 → 0.7.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/cli/app.js CHANGED
@@ -270,7 +270,7 @@ var sleep;
270
270
  var init_sleep = __esm({
271
271
  "node_modules/.pnpm/@anthropic-ai+sdk@0.92.0_zod@4.1.5/node_modules/@anthropic-ai/sdk/internal/utils/sleep.mjs"() {
272
272
  "use strict";
273
- sleep = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
273
+ sleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
274
274
  }
275
275
  });
276
276
 
@@ -1059,8 +1059,8 @@ var init_api_promise = __esm({
1059
1059
  init_parse();
1060
1060
  APIPromise = class _APIPromise extends Promise {
1061
1061
  constructor(client, responsePromise, parseResponse = defaultParseResponse) {
1062
- super((resolve3) => {
1063
- resolve3(null);
1062
+ super((resolve5) => {
1063
+ resolve5(null);
1064
1064
  });
1065
1065
  this.responsePromise = responsePromise;
1066
1066
  this.parseResponse = parseResponse;
@@ -3242,12 +3242,12 @@ var init_BetaMessageStream = __esm({
3242
3242
  }
3243
3243
  return this._emit("error", new AnthropicError(String(error43)));
3244
3244
  });
3245
- __classPrivateFieldSet(this, _BetaMessageStream_connectedPromise, new Promise((resolve3, reject) => {
3246
- __classPrivateFieldSet(this, _BetaMessageStream_resolveConnectedPromise, resolve3, "f");
3245
+ __classPrivateFieldSet(this, _BetaMessageStream_connectedPromise, new Promise((resolve5, reject) => {
3246
+ __classPrivateFieldSet(this, _BetaMessageStream_resolveConnectedPromise, resolve5, "f");
3247
3247
  __classPrivateFieldSet(this, _BetaMessageStream_rejectConnectedPromise, reject, "f");
3248
3248
  }), "f");
3249
- __classPrivateFieldSet(this, _BetaMessageStream_endPromise, new Promise((resolve3, reject) => {
3250
- __classPrivateFieldSet(this, _BetaMessageStream_resolveEndPromise, resolve3, "f");
3249
+ __classPrivateFieldSet(this, _BetaMessageStream_endPromise, new Promise((resolve5, reject) => {
3250
+ __classPrivateFieldSet(this, _BetaMessageStream_resolveEndPromise, resolve5, "f");
3251
3251
  __classPrivateFieldSet(this, _BetaMessageStream_rejectEndPromise, reject, "f");
3252
3252
  }), "f");
3253
3253
  __classPrivateFieldGet(this, _BetaMessageStream_connectedPromise, "f").catch(() => {
@@ -3417,11 +3417,11 @@ var init_BetaMessageStream = __esm({
3417
3417
  * const message = await stream.emitted('message') // rejects if the stream errors
3418
3418
  */
3419
3419
  emitted(event) {
3420
- return new Promise((resolve3, reject) => {
3420
+ return new Promise((resolve5, reject) => {
3421
3421
  __classPrivateFieldSet(this, _BetaMessageStream_catchingPromiseCreated, true, "f");
3422
3422
  if (event !== "error")
3423
3423
  this.once("error", reject);
3424
- this.once(event, resolve3);
3424
+ this.once(event, resolve5);
3425
3425
  });
3426
3426
  }
3427
3427
  async done() {
@@ -3764,7 +3764,7 @@ var init_BetaMessageStream = __esm({
3764
3764
  if (done) {
3765
3765
  return { value: void 0, done: true };
3766
3766
  }
3767
- return new Promise((resolve3, reject) => readQueue.push({ resolve: resolve3, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
3767
+ return new Promise((resolve5, reject) => readQueue.push({ resolve: resolve5, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
3768
3768
  }
3769
3769
  const chunk = pushQueue.shift();
3770
3770
  return { value: chunk, done: false };
@@ -3837,13 +3837,13 @@ Wrap your summary in <summary></summary> tags.`;
3837
3837
 
3838
3838
  // node_modules/.pnpm/@anthropic-ai+sdk@0.92.0_zod@4.1.5/node_modules/@anthropic-ai/sdk/lib/tools/BetaToolRunner.mjs
3839
3839
  function promiseWithResolvers() {
3840
- let resolve3;
3840
+ let resolve5;
3841
3841
  let reject;
3842
3842
  const promise2 = new Promise((res, rej) => {
3843
- resolve3 = res;
3843
+ resolve5 = res;
3844
3844
  reject = rej;
3845
3845
  });
3846
- return { promise: promise2, resolve: resolve3, reject };
3846
+ return { promise: promise2, resolve: resolve5, reject };
3847
3847
  }
3848
3848
  async function generateToolResponse(params, lastMessage = params.messages.at(-1), requestOptions) {
3849
3849
  if (!lastMessage || lastMessage.role !== "assistant" || !lastMessage.content || typeof lastMessage.content === "string") {
@@ -4768,9 +4768,9 @@ var init_versions2 = __esm({
4768
4768
  * );
4769
4769
  * ```
4770
4770
  */
4771
- retrieve(version2, params, options) {
4771
+ retrieve(version3, params, options) {
4772
4772
  const { skill_id, betas } = params;
4773
- return this._client.get(path`/v1/skills/${skill_id}/versions/${version2}?beta=true`, {
4773
+ return this._client.get(path`/v1/skills/${skill_id}/versions/${version3}?beta=true`, {
4774
4774
  ...options,
4775
4775
  headers: buildHeaders([
4776
4776
  { "anthropic-beta": [...betas ?? [], "skills-2025-10-02"].toString() },
@@ -4813,9 +4813,9 @@ var init_versions2 = __esm({
4813
4813
  * );
4814
4814
  * ```
4815
4815
  */
4816
- delete(version2, params, options) {
4816
+ delete(version3, params, options) {
4817
4817
  const { skill_id, betas } = params;
4818
- return this._client.delete(path`/v1/skills/${skill_id}/versions/${version2}?beta=true`, {
4818
+ return this._client.delete(path`/v1/skills/${skill_id}/versions/${version3}?beta=true`, {
4819
4819
  ...options,
4820
4820
  headers: buildHeaders([
4821
4821
  { "anthropic-beta": [...betas ?? [], "skills-2025-10-02"].toString() },
@@ -5441,12 +5441,12 @@ var init_MessageStream = __esm({
5441
5441
  }
5442
5442
  return this._emit("error", new AnthropicError(String(error43)));
5443
5443
  });
5444
- __classPrivateFieldSet(this, _MessageStream_connectedPromise, new Promise((resolve3, reject) => {
5445
- __classPrivateFieldSet(this, _MessageStream_resolveConnectedPromise, resolve3, "f");
5444
+ __classPrivateFieldSet(this, _MessageStream_connectedPromise, new Promise((resolve5, reject) => {
5445
+ __classPrivateFieldSet(this, _MessageStream_resolveConnectedPromise, resolve5, "f");
5446
5446
  __classPrivateFieldSet(this, _MessageStream_rejectConnectedPromise, reject, "f");
5447
5447
  }), "f");
5448
- __classPrivateFieldSet(this, _MessageStream_endPromise, new Promise((resolve3, reject) => {
5449
- __classPrivateFieldSet(this, _MessageStream_resolveEndPromise, resolve3, "f");
5448
+ __classPrivateFieldSet(this, _MessageStream_endPromise, new Promise((resolve5, reject) => {
5449
+ __classPrivateFieldSet(this, _MessageStream_resolveEndPromise, resolve5, "f");
5450
5450
  __classPrivateFieldSet(this, _MessageStream_rejectEndPromise, reject, "f");
5451
5451
  }), "f");
5452
5452
  __classPrivateFieldGet(this, _MessageStream_connectedPromise, "f").catch(() => {
@@ -5616,11 +5616,11 @@ var init_MessageStream = __esm({
5616
5616
  * const message = await stream.emitted('message') // rejects if the stream errors
5617
5617
  */
5618
5618
  emitted(event) {
5619
- return new Promise((resolve3, reject) => {
5619
+ return new Promise((resolve5, reject) => {
5620
5620
  __classPrivateFieldSet(this, _MessageStream_catchingPromiseCreated, true, "f");
5621
5621
  if (event !== "error")
5622
5622
  this.once("error", reject);
5623
- this.once(event, resolve3);
5623
+ this.once(event, resolve5);
5624
5624
  });
5625
5625
  }
5626
5626
  async done() {
@@ -5938,7 +5938,7 @@ var init_MessageStream = __esm({
5938
5938
  if (done) {
5939
5939
  return { value: void 0, done: true };
5940
5940
  }
5941
- return new Promise((resolve3, reject) => readQueue.push({ resolve: resolve3, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
5941
+ return new Promise((resolve5, reject) => readQueue.push({ resolve: resolve5, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
5942
5942
  }
5943
5943
  const chunk = pushQueue.shift();
5944
5944
  return { value: chunk, done: false };
@@ -7727,21 +7727,21 @@ var require_react_development = __commonJS({
7727
7727
  );
7728
7728
  actScopeDepth = prevActScopeDepth;
7729
7729
  }
7730
- function recursivelyFlushAsyncActWork(returnValue, resolve3, reject) {
7730
+ function recursivelyFlushAsyncActWork(returnValue, resolve5, reject) {
7731
7731
  var queue = ReactSharedInternals.actQueue;
7732
7732
  if (null !== queue)
7733
7733
  if (0 !== queue.length)
7734
7734
  try {
7735
7735
  flushActQueue(queue);
7736
7736
  enqueueTask(function() {
7737
- return recursivelyFlushAsyncActWork(returnValue, resolve3, reject);
7737
+ return recursivelyFlushAsyncActWork(returnValue, resolve5, reject);
7738
7738
  });
7739
7739
  return;
7740
7740
  } catch (error43) {
7741
7741
  ReactSharedInternals.thrownErrors.push(error43);
7742
7742
  }
7743
7743
  else ReactSharedInternals.actQueue = null;
7744
- 0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve3(returnValue);
7744
+ 0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve5(returnValue);
7745
7745
  }
7746
7746
  function flushActQueue(queue) {
7747
7747
  if (!isFlushing) {
@@ -7928,7 +7928,7 @@ var require_react_development = __commonJS({
7928
7928
  ));
7929
7929
  });
7930
7930
  return {
7931
- then: function(resolve3, reject) {
7931
+ then: function(resolve5, reject) {
7932
7932
  didAwaitActCall = true;
7933
7933
  thenable.then(
7934
7934
  function(returnValue) {
@@ -7938,7 +7938,7 @@ var require_react_development = __commonJS({
7938
7938
  flushActQueue(queue), enqueueTask(function() {
7939
7939
  return recursivelyFlushAsyncActWork(
7940
7940
  returnValue,
7941
- resolve3,
7941
+ resolve5,
7942
7942
  reject
7943
7943
  );
7944
7944
  });
@@ -7952,7 +7952,7 @@ var require_react_development = __commonJS({
7952
7952
  ReactSharedInternals.thrownErrors.length = 0;
7953
7953
  reject(_thrownError);
7954
7954
  }
7955
- } else resolve3(returnValue);
7955
+ } else resolve5(returnValue);
7956
7956
  },
7957
7957
  function(error43) {
7958
7958
  popActScope(prevActQueue, prevActScopeDepth);
@@ -7974,15 +7974,15 @@ var require_react_development = __commonJS({
7974
7974
  if (0 < ReactSharedInternals.thrownErrors.length)
7975
7975
  throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
7976
7976
  return {
7977
- then: function(resolve3, reject) {
7977
+ then: function(resolve5, reject) {
7978
7978
  didAwaitActCall = true;
7979
7979
  0 === prevActScopeDepth ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
7980
7980
  return recursivelyFlushAsyncActWork(
7981
7981
  returnValue$jscomp$0,
7982
- resolve3,
7982
+ resolve5,
7983
7983
  reject
7984
7984
  );
7985
- })) : resolve3(returnValue$jscomp$0);
7985
+ })) : resolve5(returnValue$jscomp$0);
7986
7986
  }
7987
7987
  };
7988
7988
  };
@@ -10066,8 +10066,8 @@ var require_react_reconciler_production = __commonJS({
10066
10066
  currentEntangledActionThenable = {
10067
10067
  status: "pending",
10068
10068
  value: void 0,
10069
- then: function(resolve3) {
10070
- entangledListeners.push(resolve3);
10069
+ then: function(resolve5) {
10070
+ entangledListeners.push(resolve5);
10071
10071
  }
10072
10072
  };
10073
10073
  }
@@ -10090,8 +10090,8 @@ var require_react_reconciler_production = __commonJS({
10090
10090
  status: "pending",
10091
10091
  value: null,
10092
10092
  reason: null,
10093
- then: function(resolve3) {
10094
- listeners.push(resolve3);
10093
+ then: function(resolve5) {
10094
+ listeners.push(resolve5);
10095
10095
  }
10096
10096
  };
10097
10097
  thenable.then(
@@ -19690,8 +19690,8 @@ var require_react_reconciler_development = __commonJS({
19690
19690
  currentEntangledActionThenable = {
19691
19691
  status: "pending",
19692
19692
  value: void 0,
19693
- then: function(resolve3) {
19694
- entangledListeners.push(resolve3);
19693
+ then: function(resolve5) {
19694
+ entangledListeners.push(resolve5);
19695
19695
  }
19696
19696
  };
19697
19697
  }
@@ -19714,8 +19714,8 @@ var require_react_reconciler_development = __commonJS({
19714
19714
  status: "pending",
19715
19715
  value: null,
19716
19716
  reason: null,
19717
- then: function(resolve3) {
19718
- listeners.push(resolve3);
19717
+ then: function(resolve5) {
19718
+ listeners.push(resolve5);
19719
19719
  }
19720
19720
  };
19721
19721
  thenable.then(
@@ -32344,14 +32344,14 @@ var require_receiver = __commonJS({
32344
32344
  * @return {(Error|RangeError)} The error
32345
32345
  * @private
32346
32346
  */
32347
- createError(ErrorCtor, message, prefix, statusCode, errorCode) {
32347
+ createError(ErrorCtor, message, prefix, statusCode, errorCode2) {
32348
32348
  this._loop = false;
32349
32349
  this._errored = true;
32350
32350
  const err = new ErrorCtor(
32351
32351
  prefix ? `Invalid WebSocket frame: ${message}` : message
32352
32352
  );
32353
32353
  Error.captureStackTrace(err, this.createError);
32354
- err.code = errorCode;
32354
+ err.code = errorCode2;
32355
32355
  err[kStatusCode] = statusCode;
32356
32356
  return err;
32357
32357
  }
@@ -33239,7 +33239,7 @@ var require_websocket = __commonJS({
33239
33239
  var http = __require("http");
33240
33240
  var net4 = __require("net");
33241
33241
  var tls = __require("tls");
33242
- var { randomBytes, createHash: createHash2 } = __require("crypto");
33242
+ var { randomBytes: randomBytes2, createHash: createHash2 } = __require("crypto");
33243
33243
  var { Duplex, Readable } = __require("stream");
33244
33244
  var { URL: URL2 } = __require("url");
33245
33245
  var PerMessageDeflate2 = require_permessage_deflate();
@@ -33769,7 +33769,7 @@ var require_websocket = __commonJS({
33769
33769
  }
33770
33770
  }
33771
33771
  const defaultPort = isSecure ? 443 : 80;
33772
- const key = randomBytes(16).toString("base64");
33772
+ const key = randomBytes2(16).toString("base64");
33773
33773
  const request = isSecure ? https.request : http.request;
33774
33774
  const protocolSet = /* @__PURE__ */ new Set();
33775
33775
  let perMessageDeflate;
@@ -34461,7 +34461,7 @@ var require_websocket_server = __commonJS({
34461
34461
  socket.on("error", socketOnError);
34462
34462
  const key = req.headers["sec-websocket-key"];
34463
34463
  const upgrade = req.headers.upgrade;
34464
- const version2 = +req.headers["sec-websocket-version"];
34464
+ const version3 = +req.headers["sec-websocket-version"];
34465
34465
  if (req.method !== "GET") {
34466
34466
  const message = "Invalid HTTP method";
34467
34467
  abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
@@ -34477,7 +34477,7 @@ var require_websocket_server = __commonJS({
34477
34477
  abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
34478
34478
  return;
34479
34479
  }
34480
- if (version2 !== 13 && version2 !== 8) {
34480
+ if (version3 !== 13 && version3 !== 8) {
34481
34481
  const message = "Missing or invalid Sec-WebSocket-Version header";
34482
34482
  abortHandshakeOrEmitwsClientError(this, req, socket, 400, message, {
34483
34483
  "Sec-WebSocket-Version": "13, 8"
@@ -34521,7 +34521,7 @@ var require_websocket_server = __commonJS({
34521
34521
  }
34522
34522
  if (this.options.verifyClient) {
34523
34523
  const info = {
34524
- origin: req.headers[`${version2 === 8 ? "sec-websocket-origin" : "origin"}`],
34524
+ origin: req.headers[`${version3 === 8 ? "sec-websocket-origin" : "origin"}`],
34525
34525
  secure: !!(req.socket.authorized || req.socket.encrypted),
34526
34526
  req
34527
34527
  };
@@ -34757,22 +34757,22 @@ var init_devtools = __esm({
34757
34757
  init_devtools_window_polyfill();
34758
34758
  init_wrapper();
34759
34759
  init_react_devtools_core();
34760
- isDevToolsReachable = async () => new Promise((resolve3) => {
34760
+ isDevToolsReachable = async () => new Promise((resolve5) => {
34761
34761
  const socket = new wrapper_default("ws://localhost:8097");
34762
34762
  const timeout = setTimeout(() => {
34763
34763
  socket.terminate();
34764
- resolve3(false);
34764
+ resolve5(false);
34765
34765
  }, 2e3);
34766
34766
  timeout.unref();
34767
34767
  socket.on("open", () => {
34768
34768
  clearTimeout(timeout);
34769
34769
  socket.terminate();
34770
- resolve3(true);
34770
+ resolve5(true);
34771
34771
  });
34772
34772
  socket.on("error", () => {
34773
34773
  clearTimeout(timeout);
34774
34774
  socket.terminate();
34775
- resolve3(false);
34775
+ resolve5(false);
34776
34776
  });
34777
34777
  });
34778
34778
  if (await isDevToolsReachable()) {
@@ -35654,8 +35654,8 @@ var Command = class {
35654
35654
  this.config.ignoreOptionDefaultValue = true;
35655
35655
  return this;
35656
35656
  }
35657
- version(version2, customFlags = "-v, --version") {
35658
- this.versionNumber = version2;
35657
+ version(version3, customFlags = "-v, --version") {
35658
+ this.versionNumber = version3;
35659
35659
  this.option(customFlags, "Display version number");
35660
35660
  return this;
35661
35661
  }
@@ -35871,8 +35871,8 @@ var CAC = class extends EventTarget {
35871
35871
  * Show version number when `-v, --version` flags appear.
35872
35872
  *
35873
35873
  */
35874
- version(version2, customFlags = "-v, --version") {
35875
- this.globalCommand.version(version2, customFlags);
35874
+ version(version3, customFlags = "-v, --version") {
35875
+ this.globalCommand.version(version3, customFlags);
35876
35876
  this.showVersionOnExit = true;
35877
35877
  return this;
35878
35878
  }
@@ -36050,7 +36050,7 @@ import * as fsp from "fs/promises";
36050
36050
  // src/shared/qq-config.ts
36051
36051
  import { readFileSync } from "fs";
36052
36052
  import { homedir } from "os";
36053
- import { join } from "path";
36053
+ import { isAbsolute, join, resolve } from "path";
36054
36054
 
36055
36055
  // node_modules/.pnpm/zod@4.1.5/node_modules/zod/v4/classic/external.js
36056
36056
  var external_exports = {};
@@ -37544,10 +37544,10 @@ var nanoid = /^[a-zA-Z0-9_-]{21}$/;
37544
37544
  var duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
37545
37545
  var extendedDuration = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
37546
37546
  var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
37547
- var uuid = (version2) => {
37548
- if (!version2)
37547
+ var uuid = (version3) => {
37548
+ if (!version3)
37549
37549
  return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
37550
- return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version2}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
37550
+ return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version3}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
37551
37551
  };
37552
37552
  var uuid4 = /* @__PURE__ */ uuid(4);
37553
37553
  var uuid6 = /* @__PURE__ */ uuid(6);
@@ -48101,7 +48101,12 @@ var qqConfigFileSchema = external_exports.object({
48101
48101
  });
48102
48102
  var cachedConfig = null;
48103
48103
  function defaultConfigPath() {
48104
- return process.env.QQ_CONFIG_FILE ?? join(homedir(), ".config", "qq", "config.json");
48104
+ const override = process.env.QQ_CONFIG_FILE?.trim();
48105
+ if (!override) {
48106
+ return join(homedir(), ".config", "qq", "config.json");
48107
+ }
48108
+ const expanded = override.startsWith("~/") ? join(homedir(), override.slice(2)) : override;
48109
+ return isAbsolute(expanded) ? expanded : resolve(homedir(), expanded);
48105
48110
  }
48106
48111
  var MAX_PATTERN_LENGTH = 256;
48107
48112
  function compilePatterns(patterns) {
@@ -48363,7 +48368,8 @@ var candidateListSchema = external_exports.array(commandCandidateSchema).min(1).
48363
48368
 
48364
48369
  // src/shared/env-file.ts
48365
48370
  import { existsSync, readFileSync as readFileSync2 } from "fs";
48366
- import { dirname, join as join2 } from "path";
48371
+ import { homedir as homedir2 } from "os";
48372
+ import { dirname, join as join2, resolve as resolve2 } from "path";
48367
48373
  function findUp(startDir, filename) {
48368
48374
  let current2 = startDir;
48369
48375
  while (true) {
@@ -48406,12 +48412,19 @@ function usableSecret(value) {
48406
48412
  const trimmed = value.trim();
48407
48413
  return trimmed === "" ? void 0 : trimmed;
48408
48414
  }
48409
- function readEnvValueFromDotEnvLocal(key, startDir = process.cwd()) {
48415
+ function envFileFor(startDir) {
48416
+ if (resolve2(startDir) === resolve2(homedir2())) {
48417
+ const homeFile = join2(homedir2(), ".env.local");
48418
+ return existsSync(homeFile) ? homeFile : null;
48419
+ }
48420
+ return findUp(startDir, ".env.local");
48421
+ }
48422
+ function readEnvValueFromDotEnvLocal(key, startDir = homedir2()) {
48410
48423
  const cacheKey = `${key}\0${startDir}`;
48411
48424
  if (envCache.has(cacheKey)) {
48412
48425
  return envCache.get(cacheKey) ?? null;
48413
48426
  }
48414
- const envPath = findUp(startDir, ".env.local");
48427
+ const envPath = envFileFor(startDir);
48415
48428
  if (!envPath) {
48416
48429
  envCache.set(cacheKey, null);
48417
48430
  return null;
@@ -48521,6 +48534,33 @@ function abortError() {
48521
48534
  function isNormalStopReason(stopReason) {
48522
48535
  return stopReason === "end_turn" || stopReason === "stop_sequence";
48523
48536
  }
48537
+ var UNPARSEABLE_RESPONSE_MESSAGE = "QueQue: response held no command candidates";
48538
+ var UNSAFE_TEXT_CHARS = new RegExp("[^\\P{Cc}\\t\\n]|\\p{Cf}", "gu");
48539
+ var UNSAFE_LINE_CHARS = /[\p{Cc}\p{Cf}]/u;
48540
+ var UNSAFE_LINE_CHARS_GLOBAL = new RegExp(UNSAFE_LINE_CHARS.source, "gu");
48541
+ function replaceUnsafeLineChars(text) {
48542
+ return text.replace(UNSAFE_LINE_CHARS_GLOBAL, " ");
48543
+ }
48544
+ function sanitizeCandidate(candidate) {
48545
+ const command = candidate.command.replace(UNSAFE_TEXT_CHARS, "").trim();
48546
+ if (command.length === 0) {
48547
+ return null;
48548
+ }
48549
+ return { command, explanation: candidate.explanation.replace(UNSAFE_TEXT_CHARS, "") };
48550
+ }
48551
+ function sanitizeCandidates(candidates) {
48552
+ return candidates.flatMap((candidate) => {
48553
+ const clean = sanitizeCandidate(candidate);
48554
+ return clean ? [clean] : [];
48555
+ });
48556
+ }
48557
+ function stripTerminalControls(candidates) {
48558
+ const cleaned = sanitizeCandidates(candidates);
48559
+ if (cleaned.length === 0) {
48560
+ throw new Error(UNPARSEABLE_RESPONSE_MESSAGE);
48561
+ }
48562
+ return cleaned;
48563
+ }
48524
48564
  function isAbortError(error43) {
48525
48565
  if (error43 === null || typeof error43 !== "object") {
48526
48566
  return false;
@@ -48653,20 +48693,99 @@ function parseCandidates(text) {
48653
48693
  function finalCandidateList(text, streamed, finishedNormally, logFields = {}) {
48654
48694
  const strict = parseStrictCandidateList(text);
48655
48695
  if (strict) {
48656
- return strict;
48696
+ return sanitizedOrPlaceholder(strict);
48657
48697
  }
48658
48698
  if (streamed.length > 0) {
48659
- return streamed;
48699
+ return sanitizedOrPlaceholder(streamed);
48660
48700
  }
48661
48701
  if (!finishedNormally) {
48662
- const complete = completeCandidates(text);
48702
+ const complete = sanitizeCandidates(completeCandidates(text));
48663
48703
  if (complete.length === 0) {
48664
48704
  void appendDebugLog("provider", "response truncated", logFields);
48665
48705
  throw new Error(TRUNCATED_RESPONSE_MESSAGE);
48666
48706
  }
48667
48707
  return complete;
48668
48708
  }
48669
- return parseCandidates(text);
48709
+ return sanitizedOrPlaceholder(parseCandidates(text));
48710
+ }
48711
+ function sanitizedOrPlaceholder(candidates) {
48712
+ const clean = sanitizeCandidates(candidates);
48713
+ return clean.length > 0 ? clean : [{ command: 'echo ""', explanation: "QueQue: unexpected response format" }];
48714
+ }
48715
+ var THINK_BLOCK_RE = /<think>[\s\S]*?(?:<\/think>|$)/gi;
48716
+ var THINK_CLOSE = "</think>";
48717
+ function stripThinking(text) {
48718
+ const close = text.toLowerCase().lastIndexOf(THINK_CLOSE);
48719
+ const afterClose = close === -1 ? text : text.slice(close + THINK_CLOSE.length);
48720
+ return afterClose.replace(THINK_BLOCK_RE, " ");
48721
+ }
48722
+ function strictListOrWrapped(text) {
48723
+ const bare = parseStrictCandidateList(text);
48724
+ if (bare) {
48725
+ return bare;
48726
+ }
48727
+ let parsed;
48728
+ try {
48729
+ parsed = JSON.parse(stripCodeFence(text));
48730
+ } catch {
48731
+ return void 0;
48732
+ }
48733
+ if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
48734
+ return void 0;
48735
+ }
48736
+ const list = candidateListSchema.safeParse(parsed.candidates);
48737
+ return list.success ? list.data : void 0;
48738
+ }
48739
+ function strictCandidateListWithoutProse(text) {
48740
+ return strictListOrWrapped(text) ?? strictListOrWrapped(stripThinking(text));
48741
+ }
48742
+ function withoutCodeFence(text) {
48743
+ return stripCodeFence(text).replace(/^```(?:json)?\s*/, "");
48744
+ }
48745
+ function hasThinkTagOutsideStrings(text) {
48746
+ let inString = false;
48747
+ let escaped = false;
48748
+ for (let i = 0; i < text.length; i++) {
48749
+ const ch = text[i];
48750
+ if (inString) {
48751
+ if (escaped) {
48752
+ escaped = false;
48753
+ } else if (ch === "\\") {
48754
+ escaped = true;
48755
+ } else if (ch === '"') {
48756
+ inString = false;
48757
+ }
48758
+ continue;
48759
+ }
48760
+ if (ch === '"') {
48761
+ inString = true;
48762
+ } else if (ch === "<" && /^<\/?think\b/i.test(text.slice(i, i + 8))) {
48763
+ return true;
48764
+ }
48765
+ }
48766
+ return false;
48767
+ }
48768
+ function answerForScan(text) {
48769
+ const body = withoutCodeFence(text);
48770
+ return /^[[{]/.test(body) && !hasThinkTagOutsideStrings(body) ? body : stripThinking(text);
48771
+ }
48772
+ function finalCandidateListWithoutProse(text, finishedNormally, logFields = {}) {
48773
+ const strict = strictCandidateListWithoutProse(text);
48774
+ if (strict) {
48775
+ return strict;
48776
+ }
48777
+ const answer = answerForScan(text);
48778
+ const arrayStart = answer.search(/\[\s*\{/);
48779
+ const closed = arrayStart === -1 ? [] : completeCandidates(answer.slice(arrayStart));
48780
+ if (closed.length > 0) {
48781
+ return closed;
48782
+ }
48783
+ if (!finishedNormally) {
48784
+ void appendDebugLog("provider", "response truncated", logFields);
48785
+ throw new Error(TRUNCATED_RESPONSE_MESSAGE);
48786
+ }
48787
+ void appendDebugLog("provider", "response unparseable", logFields);
48788
+ throw new Error(UNPARSEABLE_RESPONSE_MESSAGE);
48670
48789
  }
48671
48790
  function shouldForceSelector() {
48672
48791
  const configured = process.env.QQ_FORCE_SELECTOR ?? readEnvValueFromDotEnvLocal("QQ_FORCE_SELECTOR");
@@ -48714,7 +48833,7 @@ function buildPrompt(envelope) {
48714
48833
  async function fetchCandidates(envelope, rbuffer = "", timeoutMs = 25e3, options = {}) {
48715
48834
  const apiKey = usableSecret(process.env.ANTHROPIC_API_KEY) ?? usableSecret(readEnvValueFromDotEnvLocal("ANTHROPIC_API_KEY"));
48716
48835
  if (!apiKey) {
48717
- throw new Error("ANTHROPIC_API_KEY is required in the environment or .env.local");
48836
+ throw new Error("ANTHROPIC_API_KEY is required in the environment or ~/.env.local");
48718
48837
  }
48719
48838
  const client = await getAnthropicClient(apiKey);
48720
48839
  const prompt = buildPrompt(envelope);
@@ -48742,9 +48861,13 @@ async function fetchCandidates(envelope, rbuffer = "", timeoutMs = 25e3, options
48742
48861
  );
48743
48862
  if (onCandidate) {
48744
48863
  const scan = createCandidateScanner((candidate) => {
48745
- streamed.push(candidate);
48864
+ const clean = sanitizeCandidate(candidate);
48865
+ if (!clean) {
48866
+ return;
48867
+ }
48868
+ streamed.push(clean);
48746
48869
  if (!signal?.aborted) {
48747
- onCandidate(candidate);
48870
+ onCandidate(clean);
48748
48871
  }
48749
48872
  });
48750
48873
  stream.on("text", (textDelta) => {
@@ -48940,7 +49063,7 @@ function runClaudeTurn(options) {
48940
49063
  })
48941
49064
  );
48942
49065
  }
48943
- return new Promise((resolve3, reject) => {
49066
+ return new Promise((resolve5, reject) => {
48944
49067
  let settled = false;
48945
49068
  let sawInit = false;
48946
49069
  let sawDelta = false;
@@ -49091,7 +49214,7 @@ function runClaudeTurn(options) {
49091
49214
  return;
49092
49215
  }
49093
49216
  onStage?.("result");
49094
- finish(() => resolve3(parsed.data.result ?? ""));
49217
+ finish(() => resolve5(parsed.data.result ?? ""));
49095
49218
  };
49096
49219
  if (!prewarmed && child.pid !== void 0) {
49097
49220
  onStage?.("spawned", { pid: child.pid });
@@ -49320,12 +49443,16 @@ async function fetchClaudeCliCandidates(envelope, remainingBudgetMs, options = {
49320
49443
  };
49321
49444
  const prompt = buildPrompt(envelope);
49322
49445
  const createTextDeltaHandler = () => onCandidate ? createCandidateScanner((candidate) => {
49323
- streamed.push(candidate);
49446
+ const clean = sanitizeCandidate(candidate);
49447
+ if (!clean) {
49448
+ return;
49449
+ }
49450
+ streamed.push(clean);
49324
49451
  if (streamed.length === 1) {
49325
49452
  void appendDebugLog("provider", "cli first candidate", { ms: Date.now() - startedAt });
49326
49453
  }
49327
49454
  if (!signal?.aborted) {
49328
- onCandidate(candidate);
49455
+ onCandidate(clean);
49329
49456
  }
49330
49457
  }) : void 0;
49331
49458
  const runTurn = (child, budgetMs, initDeadlineMs) => runClaudeTurn({
@@ -49413,9 +49540,12 @@ function logTurnStage(stage, detail, ms, warm) {
49413
49540
  // src/providers/claude-default.ts
49414
49541
  var TOTAL_BUDGET_MS = 25e3;
49415
49542
  var AUTH_FAILURE_RE = /not logged in|login expired|please run \/login|failed to authenticate|oauth (token|session)/i;
49416
- var D13_MESSAGE = "QueQue: Claude is not authenticated. Run `claude /login`, or set ANTHROPIC_API_KEY in the environment or .env.local.";
49417
- var ENOENT_MESSAGE = "QueQue: Claude is not authenticated. Install Claude Code, run `claude /login`, or set ANTHROPIC_API_KEY in the environment or .env.local.";
49418
- var TIMEOUT_MESSAGE = "QueQue: Claude timed out. Run `claude /login`, or set ANTHROPIC_API_KEY in the environment or .env.local.";
49543
+ var D13_MESSAGE = "QueQue: Claude is not authenticated. Run `claude /login`, or set ANTHROPIC_API_KEY in the environment or ~/.env.local. To use OpenAI or Ollama instead, run `qq init provider`.";
49544
+ var ENOENT_MESSAGE = "QueQue: No AI provider is ready. Install Claude Code and run `claude /login`, or set ANTHROPIC_API_KEY in the environment or ~/.env.local. To use OpenAI or Ollama instead, run `qq init provider`.";
49545
+ var CLI_FAILED_MESSAGE = 'QueQue: Claude Code could not answer (claude -p failed). Try ?? again; run `claude -p "hi"` to see the error.';
49546
+ var SDK_KEY_REJECTED_MESSAGE = "QueQue: Anthropic rejected ANTHROPIC_API_KEY (HTTP 401). Check the key in your environment or ~/.env.local, remove it to use your Claude Code login, or run `qq init provider` to switch providers.";
49547
+ var SDK_KEY_REFUSED_MESSAGE = "QueQue: Anthropic refused the request for ANTHROPIC_API_KEY (HTTP 403). Check the key's permissions, remove it to use your Claude Code login, or run `qq init provider` to switch providers.";
49548
+ var TIMEOUT_MESSAGE = "QueQue: Claude timed out. Run `claude /login`, or set ANTHROPIC_API_KEY in the environment or ~/.env.local.";
49419
49549
  function remainingMs(deadline) {
49420
49550
  return Math.max(0, deadline - Date.now());
49421
49551
  }
@@ -49462,7 +49592,20 @@ function hardError(error43) {
49462
49592
  if (isAuthFailure(error43)) {
49463
49593
  return new Error(D13_MESSAGE);
49464
49594
  }
49465
- return new Error(D13_MESSAGE);
49595
+ return new Error(CLI_FAILED_MESSAGE);
49596
+ }
49597
+ function sdkError(error43) {
49598
+ if (isAbortError(error43)) {
49599
+ return error43;
49600
+ }
49601
+ const status = errorField(error43, "status");
49602
+ if (status === 401) {
49603
+ return new Error(SDK_KEY_REJECTED_MESSAGE);
49604
+ }
49605
+ if (status === 403) {
49606
+ return new Error(SDK_KEY_REFUSED_MESSAGE);
49607
+ }
49608
+ return error43;
49466
49609
  }
49467
49610
  var claudeDefaultAdapter = {
49468
49611
  async fetchCandidates(envelope, options) {
@@ -49472,7 +49615,11 @@ var claudeDefaultAdapter = {
49472
49615
  void appendDebugLog("provider", "sdk path", {
49473
49616
  path: "sdk"
49474
49617
  });
49475
- return fetchCandidates(envelope, "", remainingMs(deadline), options);
49618
+ try {
49619
+ return await fetchCandidates(envelope, "", remainingMs(deadline), options);
49620
+ } catch (error43) {
49621
+ throw sdkError(error43);
49622
+ }
49476
49623
  }
49477
49624
  try {
49478
49625
  return await fetchClaudeCliCandidates(envelope, remainingMs(deadline), options);
@@ -49491,28 +49638,693 @@ var claudeDefaultAdapter = {
49491
49638
  }
49492
49639
  };
49493
49640
 
49494
- // src/registry/context-providers.ts
49641
+ // src/providers/provider-pin.ts
49642
+ import { randomBytes } from "crypto";
49643
+ import { chmodSync, mkdirSync, readFileSync as readFileSync3, renameSync, unlinkSync, writeFileSync } from "fs";
49644
+ import { homedir as homedir3 } from "os";
49645
+ import { dirname as dirname2, isAbsolute as isAbsolute2, join as join3 } from "path";
49646
+
49647
+ // src/registry/provider-backends.ts
49495
49648
  var registry2 = /* @__PURE__ */ new Map();
49496
- function registerContextProvider(descriptor) {
49497
- if (registry2.has(descriptor.id)) {
49498
- throw new Error(`Context provider already registered: "${descriptor.id}"`);
49649
+ function registerProviderBackend(registration) {
49650
+ if (registry2.has(registration.id)) {
49651
+ throw new Error(`Provider backend already registered: "${registration.id}"`);
49499
49652
  }
49500
- registry2.set(descriptor.id, descriptor);
49653
+ registry2.set(registration.id, registration);
49501
49654
  }
49502
- function listContextProviders() {
49503
- return Array.from(registry2.values());
49655
+ function getProviderAdapter(id) {
49656
+ return registry2.get(id)?.adapter;
49504
49657
  }
49505
49658
 
49506
- // src/registry/provider-backends.ts
49659
+ // src/providers/resolver.ts
49660
+ var MISSING_ADAPTER_MESSAGE = "QueQue: Claude provider is not registered \u2014 was bootstrapBuiltins() called?";
49661
+ function resolveClaudeDefaultAdapter() {
49662
+ const adapter = getProviderAdapter("claude-cli");
49663
+ if (!adapter) {
49664
+ throw new Error(MISSING_ADAPTER_MESSAGE);
49665
+ }
49666
+ return adapter;
49667
+ }
49668
+
49669
+ // src/providers/provider-pin.ts
49670
+ var PROVIDER_PIN_VERSION = 1;
49671
+ var OLLAMA_DEFAULT_BASE_URL = "http://localhost:11434";
49672
+ var modelName = external_exports.string().trim().min(1).max(200).regex(/^[^\p{Cc}]+$/u, { message: "model must not contain control characters" });
49673
+ var httpUrl2 = external_exports.string().min(1).refine((value) => !UNSAFE_LINE_CHARS.test(value), {
49674
+ message: "baseUrl must not contain control or format characters"
49675
+ }).refine(
49676
+ (value) => {
49677
+ try {
49678
+ const { protocol, username, password } = new URL(value);
49679
+ return (protocol === "http:" || protocol === "https:") && !username && !password;
49680
+ } catch {
49681
+ return false;
49682
+ }
49683
+ },
49684
+ { message: "baseUrl must be an http or https URL without a username or password" }
49685
+ );
49686
+ var version2 = external_exports.literal(PROVIDER_PIN_VERSION);
49687
+ var providerPinSchema = external_exports.discriminatedUnion("provider", [
49688
+ external_exports.strictObject({ version: version2, provider: external_exports.literal("claude") }),
49689
+ external_exports.strictObject({ version: version2, provider: external_exports.literal("openai"), model: modelName.optional() }),
49690
+ external_exports.strictObject({
49691
+ version: version2,
49692
+ provider: external_exports.literal("ollama"),
49693
+ model: modelName,
49694
+ baseUrl: httpUrl2.optional()
49695
+ })
49696
+ ]);
49697
+ var PIN_BACKEND_IDS = {
49698
+ claude: "claude-cli",
49699
+ openai: "openai",
49700
+ ollama: "ollama"
49701
+ };
49702
+ function providerPinPath() {
49703
+ const override = process.env.QQ_PROVIDER_FILE?.trim();
49704
+ return override ? override : join3(homedir3(), ".config", "qq", "provider.json");
49705
+ }
49706
+ var RELATIVE_PIN_PATH_MESSAGE = "QQ_PROVIDER_FILE must be an absolute path";
49707
+ var MAX_ISSUE_REASON = 120;
49708
+ function describeIssues(error43) {
49709
+ const parts = error43.issues.map((issue2) => {
49710
+ if (issue2.code === "unrecognized_keys") {
49711
+ return `unknown key ${issue2.keys.join(", ")}`;
49712
+ }
49713
+ return issue2.path.length > 0 ? issue2.path.join(".") : issue2.code;
49714
+ });
49715
+ const reason = [...new Set(parts)].join(", ").replace(new RegExp("\\p{Cc}", "gu"), "?");
49716
+ return reason.length > MAX_ISSUE_REASON ? `${reason.slice(0, MAX_ISSUE_REASON - 1)}\u2026` : reason;
49717
+ }
49718
+ function loadProviderPin() {
49719
+ const path5 = providerPinPath();
49720
+ if (!isAbsolute2(path5)) {
49721
+ return { kind: "invalid", path: path5, message: RELATIVE_PIN_PATH_MESSAGE };
49722
+ }
49723
+ let raw;
49724
+ try {
49725
+ raw = readFileSync3(path5, "utf8");
49726
+ } catch (error43) {
49727
+ const code = error43.code;
49728
+ if (code === "ENOENT") {
49729
+ return { kind: "absent" };
49730
+ }
49731
+ return { kind: "invalid", path: path5, message: code ?? "unreadable" };
49732
+ }
49733
+ let parsed;
49734
+ try {
49735
+ parsed = JSON.parse(raw);
49736
+ } catch {
49737
+ return { kind: "invalid", path: path5, message: "not valid JSON" };
49738
+ }
49739
+ const result = providerPinSchema.safeParse(parsed);
49740
+ if (!result.success) {
49741
+ return { kind: "invalid", path: path5, message: describeIssues(result.error) };
49742
+ }
49743
+ return { kind: "pinned", pin: result.data };
49744
+ }
49745
+ function writeProviderPin(pin) {
49746
+ const parsed = providerPinSchema.parse(pin);
49747
+ const target = providerPinPath();
49748
+ if (!isAbsolute2(target)) {
49749
+ throw new Error(RELATIVE_PIN_PATH_MESSAGE);
49750
+ }
49751
+ mkdirSync(dirname2(target), { recursive: true, mode: 448 });
49752
+ const temp = `${target}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
49753
+ try {
49754
+ writeFileSync(temp, `${JSON.stringify(parsed, null, 2)}
49755
+ `, { mode: 384, flag: "wx" });
49756
+ chmodSync(temp, 384);
49757
+ renameSync(temp, target);
49758
+ } catch (error43) {
49759
+ try {
49760
+ unlinkSync(temp);
49761
+ } catch {
49762
+ }
49763
+ throw error43;
49764
+ }
49765
+ return target;
49766
+ }
49767
+ function resolveProviderAdapter() {
49768
+ const state = loadProviderPin();
49769
+ if (state.kind === "absent") {
49770
+ void appendDebugLog("provider", "provider selected", { provider: "claude", source: "default" });
49771
+ return resolveClaudeDefaultAdapter();
49772
+ }
49773
+ if (state.kind === "invalid") {
49774
+ void appendDebugLog("provider", "provider selected", { source: "invalid" });
49775
+ throw new Error(
49776
+ `QueQue: ${state.path} is not a valid provider pin (${state.message}). Fix the file or run \`qq init provider\`.`
49777
+ );
49778
+ }
49779
+ const { provider } = state.pin;
49780
+ void appendDebugLog("provider", "provider selected", { provider, source: "pin" });
49781
+ if (provider === "claude") {
49782
+ return resolveClaudeDefaultAdapter();
49783
+ }
49784
+ const adapter = getProviderAdapter(PIN_BACKEND_IDS[provider]);
49785
+ if (!adapter) {
49786
+ throw new Error(
49787
+ `QueQue: provider '${provider}' is not registered \u2014 was bootstrapBuiltins() called?`
49788
+ );
49789
+ }
49790
+ return adapter;
49791
+ }
49792
+
49793
+ // src/providers/structured-output.ts
49794
+ var MAX_OUTPUT_TOKENS = SDK_MAX_TOKENS;
49795
+ var CANDIDATE_LIST_JSON_SCHEMA = {
49796
+ type: "array",
49797
+ minItems: 1,
49798
+ maxItems: 5,
49799
+ items: {
49800
+ type: "object",
49801
+ properties: {
49802
+ command: { type: "string", minLength: 1 },
49803
+ explanation: { type: "string" }
49804
+ },
49805
+ required: ["command", "explanation"],
49806
+ additionalProperties: false
49807
+ }
49808
+ };
49809
+ var WRAPPED_CANDIDATE_LIST_JSON_SCHEMA = {
49810
+ type: "object",
49811
+ properties: {
49812
+ candidates: CANDIDATE_LIST_JSON_SCHEMA
49813
+ },
49814
+ required: ["candidates"],
49815
+ additionalProperties: false
49816
+ };
49817
+ function closedCandidates(content, logFields) {
49818
+ try {
49819
+ return finalCandidateListWithoutProse(content, false, logFields);
49820
+ } catch (error43) {
49821
+ if (error43 instanceof Error && error43.message === TRUNCATED_RESPONSE_MESSAGE) {
49822
+ return [];
49823
+ }
49824
+ throw error43;
49825
+ }
49826
+ }
49827
+ async function candidatesWithCutOffRetry(first, retry, logFields = {}, budget) {
49828
+ if (first.finishedNormally) {
49829
+ return finalCandidateListWithoutProse(first.content, true, logFields);
49830
+ }
49831
+ const complete = strictCandidateListWithoutProse(first.content);
49832
+ if (complete) {
49833
+ return complete;
49834
+ }
49835
+ const closed = closedCandidates(first.content, logFields);
49836
+ void appendDebugLog("provider", "response cut off, retrying once", logFields);
49837
+ try {
49838
+ const second = await retry();
49839
+ return finalCandidateListWithoutProse(second.content, second.finishedNormally, logFields);
49840
+ } catch (error43) {
49841
+ if (isAbortError(error43)) {
49842
+ throw error43;
49843
+ }
49844
+ if (closed.length === 0) {
49845
+ if (budget?.aborted) {
49846
+ void appendDebugLog("provider", "response truncated", logFields);
49847
+ throw new Error(TRUNCATED_RESPONSE_MESSAGE);
49848
+ }
49849
+ throw error43;
49850
+ }
49851
+ return closed;
49852
+ }
49853
+ }
49854
+
49855
+ // src/providers/ollama.ts
49856
+ var OLLAMA_TIMEOUT_MS = 25e3;
49857
+ var OLLAMA_NUM_PREDICT = 2048;
49858
+ var OLLAMA_NUM_CTX = 8192;
49859
+ var MAX_ERROR_DETAIL = 160;
49860
+ var SWITCH_HINT = "Run `qq init provider` to switch providers.";
49861
+ var UNREACHABLE_CODES = /* @__PURE__ */ new Set(["ECONNREFUSED", "ENOTFOUND", "EHOSTUNREACH"]);
49862
+ function errorCode(error43) {
49863
+ const cause = error43?.cause;
49864
+ return typeof cause?.code === "string" ? cause.code : void 0;
49865
+ }
49866
+ function errorName(error43) {
49867
+ const name = error43?.name;
49868
+ return typeof name === "string" ? name : void 0;
49869
+ }
49870
+ function oneLine(text) {
49871
+ const flat = replaceUnsafeLineChars(text).replace(/\s+/g, " ").trim();
49872
+ return flat.length > MAX_ERROR_DETAIL ? `${flat.slice(0, MAX_ERROR_DETAIL)}\u2026` : flat;
49873
+ }
49874
+ function unexpectedResponse() {
49875
+ return new Error(`QueQue: Ollama returned an unexpected response. ${SWITCH_HINT}`);
49876
+ }
49877
+ function mapRequestFailure(error43, origin, timeoutMs, signal) {
49878
+ if (signal?.aborted) {
49879
+ return abortError();
49880
+ }
49881
+ const name = errorName(error43);
49882
+ if (name === "TimeoutError" || name === "AbortError") {
49883
+ const seconds = Math.ceil(timeoutMs / 1e3);
49884
+ return new Error(
49885
+ `QueQue: Ollama did not answer within ${seconds}s (the model may still be loading). Try ?? again.`
49886
+ );
49887
+ }
49888
+ const code = errorCode(error43);
49889
+ if (code && UNREACHABLE_CODES.has(code)) {
49890
+ return new Error(
49891
+ `QueQue: Ollama is not reachable at ${origin}. Start it with \`ollama serve\`, or run \`qq init provider\` to switch providers.`
49892
+ );
49893
+ }
49894
+ return new Error(
49895
+ `QueQue: Ollama request to ${origin} failed (${code ?? name ?? "error"}). ${SWITCH_HINT}`
49896
+ );
49897
+ }
49898
+ function ollamaApiUrl(baseUrl, path5) {
49899
+ const url2 = new URL(baseUrl);
49900
+ url2.pathname = `${url2.pathname.replace(/\/+$/, "")}/${path5}`;
49901
+ url2.search = "";
49902
+ url2.hash = "";
49903
+ return url2;
49904
+ }
49905
+ async function readErrorField(response) {
49906
+ try {
49907
+ const body = await response.json();
49908
+ if (typeof body?.error === "string" && body.error.trim() !== "") {
49909
+ return body.error;
49910
+ }
49911
+ } catch {
49912
+ }
49913
+ return void 0;
49914
+ }
49915
+ async function readErrorDetail(response) {
49916
+ const error43 = await readErrorField(response);
49917
+ if (error43 !== void 0) {
49918
+ return oneLine(error43);
49919
+ }
49920
+ return oneLine(response.statusText) || "no detail";
49921
+ }
49922
+ async function fetchOllamaCandidates(envelope, settings, timeoutMs = OLLAMA_TIMEOUT_MS, options = {}) {
49923
+ const { signal } = options;
49924
+ if (signal?.aborted) {
49925
+ throw abortError();
49926
+ }
49927
+ const url2 = ollamaApiUrl(settings.baseUrl, "api/chat");
49928
+ const { origin } = url2;
49929
+ const timeout = AbortSignal.timeout(timeoutMs);
49930
+ const requestSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
49931
+ const requestBody = JSON.stringify({
49932
+ model: settings.model,
49933
+ stream: false,
49934
+ think: false,
49935
+ format: CANDIDATE_LIST_JSON_SCHEMA,
49936
+ options: { num_predict: OLLAMA_NUM_PREDICT, num_ctx: OLLAMA_NUM_CTX },
49937
+ messages: [
49938
+ { role: "system", content: buildSystemPrompt(envelope) },
49939
+ { role: "user", content: buildPrompt(envelope) }
49940
+ ]
49941
+ });
49942
+ const postChat = async () => {
49943
+ const started = Date.now();
49944
+ const logRequest = (status) => {
49945
+ void appendDebugLog("provider", "ollama request", {
49946
+ model: settings.model,
49947
+ status,
49948
+ durationMs: Date.now() - started
49949
+ });
49950
+ };
49951
+ let response;
49952
+ try {
49953
+ response = await fetch(url2, {
49954
+ method: "POST",
49955
+ headers: { "content-type": "application/json" },
49956
+ body: requestBody,
49957
+ signal: requestSignal
49958
+ });
49959
+ } catch (error43) {
49960
+ logRequest(null);
49961
+ throw mapRequestFailure(error43, origin, timeoutMs, signal);
49962
+ }
49963
+ logRequest(response.status);
49964
+ if (response.status === 404) {
49965
+ const error43 = await readErrorField(response);
49966
+ if (error43 !== void 0 && /\bmodel\b/i.test(error43)) {
49967
+ throw new Error(
49968
+ `QueQue: Ollama model '${settings.model}' is not installed. Run \`ollama pull ${settings.model}\`, or run \`qq init provider\` to pick another model.`
49969
+ );
49970
+ }
49971
+ throw new Error(
49972
+ `QueQue: Ollama returned HTTP 404 from ${origin}. Check "baseUrl" in provider.json, or run \`qq init provider\`.`
49973
+ );
49974
+ }
49975
+ if (!response.ok) {
49976
+ const detail = await readErrorDetail(response);
49977
+ throw new Error(`QueQue: Ollama returned HTTP ${response.status}: ${detail}. ${SWITCH_HINT}`);
49978
+ }
49979
+ let raw;
49980
+ try {
49981
+ raw = await response.text();
49982
+ } catch (error43) {
49983
+ throw mapRequestFailure(error43, origin, timeoutMs, signal);
49984
+ }
49985
+ let body;
49986
+ try {
49987
+ body = JSON.parse(raw);
49988
+ } catch {
49989
+ throw unexpectedResponse();
49990
+ }
49991
+ const content = body?.message?.content;
49992
+ if (typeof content !== "string") {
49993
+ throw unexpectedResponse();
49994
+ }
49995
+ return { content, finishedNormally: body.done_reason === "stop" };
49996
+ };
49997
+ const first = await postChat();
49998
+ try {
49999
+ return ensureSelectableCandidates(
50000
+ stripTerminalControls(
50001
+ await candidatesWithCutOffRetry(first, postChat, { model: settings.model }, timeout)
50002
+ )
50003
+ );
50004
+ } catch (error43) {
50005
+ if (error43 instanceof Error && error43.message === TRUNCATED_RESPONSE_MESSAGE) {
50006
+ throw new Error(
50007
+ "QueQue: Ollama response was cut off before a full command. Try ?? again, or run `qq init provider` to pick another model."
50008
+ );
50009
+ }
50010
+ if (error43 instanceof Error && error43.message === UNPARSEABLE_RESPONSE_MESSAGE) {
50011
+ throw unexpectedResponse();
50012
+ }
50013
+ throw error43;
50014
+ }
50015
+ }
50016
+ var ollamaAdapter = {
50017
+ fetchCandidates(envelope, options) {
50018
+ const state = loadProviderPin();
50019
+ if (state.kind !== "pinned" || state.pin.provider !== "ollama") {
50020
+ return Promise.reject(
50021
+ new Error("QueQue: Ollama is not the pinned provider. Run `qq init provider`.")
50022
+ );
50023
+ }
50024
+ return fetchOllamaCandidates(
50025
+ envelope,
50026
+ { baseUrl: state.pin.baseUrl ?? OLLAMA_DEFAULT_BASE_URL, model: state.pin.model },
50027
+ OLLAMA_TIMEOUT_MS,
50028
+ options
50029
+ );
50030
+ }
50031
+ };
50032
+ var OLLAMA_LIST_TIMEOUT_MS = 2e3;
50033
+ var CONTROL_BYTES = /[\p{Cc}]/u;
50034
+ function listableModelName(value) {
50035
+ return typeof value === "string" && value.trim().length > 0 && value.length <= 200 && !CONTROL_BYTES.test(value);
50036
+ }
50037
+ async function listOllamaModels(baseUrl = OLLAMA_DEFAULT_BASE_URL, timeoutMs = OLLAMA_LIST_TIMEOUT_MS) {
50038
+ const signal = AbortSignal.timeout(timeoutMs);
50039
+ let response;
50040
+ try {
50041
+ response = await fetch(ollamaApiUrl(baseUrl, "api/tags"), { signal });
50042
+ } catch {
50043
+ return { ok: false, reason: "unreachable" };
50044
+ }
50045
+ if (!response.ok) {
50046
+ await response.body?.cancel().catch(() => void 0);
50047
+ return { ok: false, reason: "http", status: response.status };
50048
+ }
50049
+ let body;
50050
+ try {
50051
+ body = await response.json();
50052
+ } catch {
50053
+ return signal.aborted ? { ok: false, reason: "unreachable" } : { ok: false, reason: "http", status: response.status };
50054
+ }
50055
+ const models = body?.models;
50056
+ if (!Array.isArray(models)) {
50057
+ return { ok: false, reason: "http", status: response.status };
50058
+ }
50059
+ const names = models.map((entry) => entry?.name).filter(listableModelName);
50060
+ return { ok: true, models: names };
50061
+ }
50062
+
50063
+ // src/providers/openai.ts
50064
+ var OPENAI_CHAT_COMPLETIONS_URL = "https://api.openai.com/v1/chat/completions";
50065
+ var OPENAI_DEFAULT_MODEL = "gpt-5.5";
50066
+ var OPENAI_TIMEOUT_MS = 25e3;
50067
+ var OPENAI_REASONING_EFFORT = "low";
50068
+ var OPENAI_RETRY_REASONING_EFFORTS = ["none", "minimal", "low"];
50069
+ var OPENAI_RESPONSE_FORMAT_NAME = "command_candidates";
50070
+ var modelsRejectingDefaultEffort = /* @__PURE__ */ new Set();
50071
+ var modelsRejectingSchema = /* @__PURE__ */ new Set();
50072
+ var rejectedEffortsByModel = /* @__PURE__ */ new Map();
50073
+ function rememberRejectedEffort(model, effort) {
50074
+ const rejected = rejectedEffortsByModel.get(model) ?? /* @__PURE__ */ new Set();
50075
+ rejected.add(effort);
50076
+ rejectedEffortsByModel.set(model, rejected);
50077
+ }
50078
+ function lookupOpenAiKey() {
50079
+ return usableSecret(process.env.OPENAI_API_KEY) ?? usableSecret(readEnvValueFromDotEnvLocal("OPENAI_API_KEY"));
50080
+ }
50081
+ var SAFE_ERROR_CODE = /^[a-z0-9_]{1,64}$/;
50082
+ var SWITCH_HINT2 = "run `qq init provider` to switch providers";
50083
+ var HEADER_SAFE_KEY = /^[\x21-\x7e]+$/;
50084
+ function errorName2(error43) {
50085
+ const name = error43?.name;
50086
+ return typeof name === "string" ? name : void 0;
50087
+ }
50088
+ function unexpectedResponse2() {
50089
+ return new Error("QueQue: OpenAI returned an unexpected response.");
50090
+ }
50091
+ function declinedQuery() {
50092
+ return new Error("QueQue: OpenAI declined this query. Rephrase it and press ?? again.");
50093
+ }
50094
+ function oneLine2(text) {
50095
+ return text.replace(/\s+/g, " ").trim();
50096
+ }
50097
+ async function readSafeErrorFields(response) {
50098
+ try {
50099
+ const body = await response.json();
50100
+ const code = body?.error?.code;
50101
+ const param = body?.error?.param;
50102
+ return {
50103
+ code: typeof code === "string" && SAFE_ERROR_CODE.test(code) ? code : void 0,
50104
+ rejectsReasoningEffort: param === "reasoning_effort",
50105
+ rejectsResponseFormat: typeof param === "string" && (param === "response_format" || param.startsWith("response_format."))
50106
+ };
50107
+ } catch {
50108
+ return { code: void 0, rejectsReasoningEffort: false, rejectsResponseFormat: false };
50109
+ }
50110
+ }
50111
+ function statusFailure(status, model, code) {
50112
+ switch (status) {
50113
+ case 401:
50114
+ return new Error(
50115
+ `QueQue: OpenAI rejected OPENAI_API_KEY (HTTP 401). Check the key, or ${SWITCH_HINT2}.`
50116
+ );
50117
+ case 403:
50118
+ return new Error(
50119
+ "QueQue: OpenAI refused the request (HTTP 403). Check the key's project access, or run `qq init provider`."
50120
+ );
50121
+ case 404:
50122
+ return new Error(
50123
+ `QueQue: OpenAI model '${oneLine2(model)}' is not available to this key (HTTP 404). Set "model" in ~/.config/qq/provider.json, or run \`qq init provider\`.`
50124
+ );
50125
+ case 429:
50126
+ return new Error(
50127
+ `QueQue: OpenAI rate limit or quota reached (HTTP 429). Try again shortly, or ${SWITCH_HINT2}.`
50128
+ );
50129
+ default:
50130
+ return new Error(
50131
+ `QueQue: OpenAI request failed (HTTP ${status}${code ? `, code ${code}` : ""}).`
50132
+ );
50133
+ }
50134
+ }
50135
+ function mapRequestFailure2(error43, timeoutMs, signal) {
50136
+ if (signal?.aborted) {
50137
+ return abortError();
50138
+ }
50139
+ const name = errorName2(error43);
50140
+ if (name === "TimeoutError" || name === "AbortError") {
50141
+ const seconds = Math.ceil(timeoutMs / 1e3);
50142
+ return new Error(`QueQue: OpenAI did not answer within ${seconds}s. Try ?? again.`);
50143
+ }
50144
+ if (error43 instanceof TypeError) {
50145
+ return new Error(
50146
+ `QueQue: could not reach api.openai.com. Check your connection, or ${SWITCH_HINT2}.`
50147
+ );
50148
+ }
50149
+ return new Error("QueQue: OpenAI request failed.");
50150
+ }
50151
+ async function fetchOpenAiCandidates(envelope, settings, timeoutMs = OPENAI_TIMEOUT_MS, options = {}) {
50152
+ const { signal } = options;
50153
+ if (signal?.aborted) {
50154
+ throw abortError();
50155
+ }
50156
+ const apiKey = lookupOpenAiKey();
50157
+ if (!apiKey) {
50158
+ throw new Error(
50159
+ "QueQue: OpenAI is pinned but OPENAI_API_KEY is not set for QueQue. Export it (or add it to ~/.env.local), then run `qq init provider` to refresh the background daemon."
50160
+ );
50161
+ }
50162
+ if (!HEADER_SAFE_KEY.test(apiKey)) {
50163
+ throw new Error(
50164
+ "QueQue: OPENAI_API_KEY contains invalid characters (spaces, line breaks or non-ASCII). Check the key in your environment or ~/.env.local."
50165
+ );
50166
+ }
50167
+ const timeout = AbortSignal.timeout(timeoutMs);
50168
+ const requestSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
50169
+ const { model } = settings;
50170
+ const messages = [
50171
+ { role: "developer", content: buildSystemPrompt(envelope) },
50172
+ { role: "user", content: buildPrompt(envelope) }
50173
+ ];
50174
+ let useSchema = !modelsRejectingSchema.has(model);
50175
+ const requestBody = (effort) => JSON.stringify({
50176
+ model,
50177
+ messages,
50178
+ max_completion_tokens: MAX_OUTPUT_TOKENS,
50179
+ ...effort === void 0 ? {} : { reasoning_effort: effort },
50180
+ ...useSchema ? {
50181
+ response_format: {
50182
+ type: "json_schema",
50183
+ json_schema: {
50184
+ name: OPENAI_RESPONSE_FORMAT_NAME,
50185
+ strict: true,
50186
+ schema: WRAPPED_CANDIDATE_LIST_JSON_SCHEMA
50187
+ }
50188
+ }
50189
+ } : {}
50190
+ });
50191
+ const postChat = async (effort) => {
50192
+ const started = Date.now();
50193
+ const logRequest = (status) => {
50194
+ void appendDebugLog("provider", "openai request", {
50195
+ model,
50196
+ status,
50197
+ durationMs: Date.now() - started
50198
+ });
50199
+ };
50200
+ let response;
50201
+ try {
50202
+ response = await fetch(OPENAI_CHAT_COMPLETIONS_URL, {
50203
+ method: "POST",
50204
+ headers: {
50205
+ authorization: `Bearer ${apiKey}`,
50206
+ "content-type": "application/json"
50207
+ },
50208
+ body: requestBody(effort),
50209
+ signal: requestSignal
50210
+ });
50211
+ } catch (error43) {
50212
+ logRequest(null);
50213
+ throw mapRequestFailure2(error43, timeoutMs, signal);
50214
+ }
50215
+ logRequest(response.status);
50216
+ if (!response.ok) {
50217
+ const { code, rejectsReasoningEffort, rejectsResponseFormat } = await readSafeErrorFields(response);
50218
+ if (response.status === 400 && rejectsReasoningEffort && effort !== void 0) {
50219
+ void appendDebugLog("provider", "openai reasoning_effort rejected", { model, effort });
50220
+ rememberRejectedEffort(model, effort);
50221
+ return void 0;
50222
+ }
50223
+ if (response.status === 400 && rejectsResponseFormat && useSchema) {
50224
+ modelsRejectingSchema.add(model);
50225
+ useSchema = false;
50226
+ void appendDebugLog("provider", "openai response_format rejected", { model });
50227
+ return postChat(effort);
50228
+ }
50229
+ throw statusFailure(response.status, model, code);
50230
+ }
50231
+ let raw;
50232
+ try {
50233
+ raw = await response.text();
50234
+ } catch (error43) {
50235
+ throw mapRequestFailure2(error43, timeoutMs, signal);
50236
+ }
50237
+ let body;
50238
+ try {
50239
+ body = JSON.parse(raw);
50240
+ } catch {
50241
+ throw unexpectedResponse2();
50242
+ }
50243
+ const choice = Array.isArray(body?.choices) ? body.choices[0] : void 0;
50244
+ const message = choice?.message;
50245
+ if (!message || typeof message !== "object") {
50246
+ throw unexpectedResponse2();
50247
+ }
50248
+ if (choice?.finish_reason === "content_filter") {
50249
+ throw declinedQuery();
50250
+ }
50251
+ const finishedNormally = choice?.finish_reason === "stop";
50252
+ const { content, refusal } = message;
50253
+ if (typeof content !== "string") {
50254
+ if (typeof refusal === "string" && refusal.trim() !== "") {
50255
+ throw declinedQuery();
50256
+ }
50257
+ if (finishedNormally) {
50258
+ throw unexpectedResponse2();
50259
+ }
50260
+ return { content: "", finishedNormally };
50261
+ }
50262
+ return { content, finishedNormally };
50263
+ };
50264
+ const firstTurn = async (efforts) => {
50265
+ for (const effort of efforts) {
50266
+ const turn = await postChat(effort);
50267
+ if (turn) {
50268
+ return { turn, effort };
50269
+ }
50270
+ }
50271
+ throw unexpectedResponse2();
50272
+ };
50273
+ const knownRejection = modelsRejectingDefaultEffort.has(model);
50274
+ const firstEfforts = knownRejection ? [void 0] : [OPENAI_REASONING_EFFORT, void 0];
50275
+ const first = await firstTurn(firstEfforts);
50276
+ if (first.effort === void 0 && firstEfforts[0] === OPENAI_REASONING_EFFORT) {
50277
+ modelsRejectingDefaultEffort.add(model);
50278
+ }
50279
+ const rejectedEfforts = rejectedEffortsByModel.get(model);
50280
+ const retryEfforts = first.effort === OPENAI_REASONING_EFFORT ? [
50281
+ ...OPENAI_RETRY_REASONING_EFFORTS.filter((effort) => !rejectedEfforts?.has(effort)),
50282
+ void 0
50283
+ ] : [void 0];
50284
+ const retry = async () => (await firstTurn(retryEfforts)).turn;
50285
+ try {
50286
+ return ensureSelectableCandidates(
50287
+ stripTerminalControls(await candidatesWithCutOffRetry(first.turn, retry, { model }, timeout))
50288
+ );
50289
+ } catch (error43) {
50290
+ if (error43 instanceof Error && error43.message === TRUNCATED_RESPONSE_MESSAGE) {
50291
+ throw new Error(
50292
+ "QueQue: OpenAI response was cut off before a full command. Try ?? again, or run `qq init provider` to pick another model."
50293
+ );
50294
+ }
50295
+ if (error43 instanceof Error && error43.message === UNPARSEABLE_RESPONSE_MESSAGE) {
50296
+ throw unexpectedResponse2();
50297
+ }
50298
+ throw error43;
50299
+ }
50300
+ }
50301
+ var openaiAdapter = {
50302
+ fetchCandidates(envelope, options) {
50303
+ const state = loadProviderPin();
50304
+ if (state.kind !== "pinned" || state.pin.provider !== "openai") {
50305
+ return Promise.reject(
50306
+ new Error("QueQue: OpenAI is not the pinned provider. Run `qq init provider`.")
50307
+ );
50308
+ }
50309
+ return fetchOpenAiCandidates(
50310
+ envelope,
50311
+ { model: state.pin.model ?? OPENAI_DEFAULT_MODEL },
50312
+ OPENAI_TIMEOUT_MS,
50313
+ options
50314
+ );
50315
+ }
50316
+ };
50317
+
50318
+ // src/registry/context-providers.ts
49507
50319
  var registry3 = /* @__PURE__ */ new Map();
49508
- function registerProviderBackend(registration) {
49509
- if (registry3.has(registration.id)) {
49510
- throw new Error(`Provider backend already registered: "${registration.id}"`);
50320
+ function registerContextProvider(descriptor) {
50321
+ if (registry3.has(descriptor.id)) {
50322
+ throw new Error(`Context provider already registered: "${descriptor.id}"`);
49511
50323
  }
49512
- registry3.set(registration.id, registration);
50324
+ registry3.set(descriptor.id, descriptor);
49513
50325
  }
49514
- function getProviderAdapter(id) {
49515
- return registry3.get(id)?.adapter;
50326
+ function listContextProviders() {
50327
+ return Array.from(registry3.values());
49516
50328
  }
49517
50329
 
49518
50330
  // src/registry/shell-adapters.ts
@@ -49570,6 +50382,18 @@ function bootstrapBuiltins() {
49570
50382
  description: "Claude Code print-mode adapter with SDK rescue",
49571
50383
  adapter: claudeDefaultAdapter
49572
50384
  });
50385
+ registerProviderBackend({
50386
+ id: "ollama",
50387
+ name: "Ollama (local)",
50388
+ description: "Local Ollama /api/chat adapter \u2014 selected only by a provider.json pin",
50389
+ adapter: ollamaAdapter
50390
+ });
50391
+ registerProviderBackend({
50392
+ id: "openai",
50393
+ name: "OpenAI",
50394
+ description: "OpenAI Chat Completions adapter \u2014 selected only by a provider.json pin",
50395
+ adapter: openaiAdapter
50396
+ });
49573
50397
  }
49574
50398
 
49575
50399
  // src/client/run-foreground.ts
@@ -54923,10 +55747,10 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
54923
55747
  return 3;
54924
55748
  }
54925
55749
  if ("TERM_PROGRAM" in env2) {
54926
- const version2 = Number.parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
55750
+ const version3 = Number.parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
54927
55751
  switch (env2.TERM_PROGRAM) {
54928
55752
  case "iTerm.app": {
54929
- return version2 >= 3 ? 3 : 2;
55753
+ return version3 >= 3 ? 3 : 2;
54930
55754
  }
54931
55755
  case "Apple_Terminal": {
54932
55756
  return 2;
@@ -57342,8 +58166,8 @@ var kittyModifiers = {
57342
58166
  var noop2 = () => {
57343
58167
  };
57344
58168
  var textEncoder = new TextEncoder();
57345
- var yieldImmediate = async () => new Promise((resolve3) => {
57346
- setImmediate(resolve3);
58169
+ var yieldImmediate = async () => new Promise((resolve5) => {
58170
+ setImmediate(resolve5);
57347
58171
  });
57348
58172
  var kittyQueryEscapeByte = 27;
57349
58173
  var kittyQueryOpenBracketByte = 91;
@@ -57560,8 +58384,8 @@ var Ink = class {
57560
58384
  };
57561
58385
  }
57562
58386
  this.initKittyKeyboard();
57563
- this.exitPromise = new Promise((resolve3, reject) => {
57564
- this.resolveExitPromise = resolve3;
58387
+ this.exitPromise = new Promise((resolve5, reject) => {
58388
+ this.resolveExitPromise = resolve5;
57565
58389
  this.rejectExitPromise = reject;
57566
58390
  });
57567
58391
  void this.exitPromise.catch(noop2);
@@ -57872,9 +58696,9 @@ var Ink = class {
57872
58696
  settleThrottle(this.throttledOnRender, canWriteToStdout);
57873
58697
  settleThrottle(this.throttledLog, canWriteToStdout);
57874
58698
  if (canWriteToStdout && hasWritableState) {
57875
- await new Promise((resolve3) => {
58699
+ await new Promise((resolve5) => {
57876
58700
  this.options.stdout.write("", () => {
57877
- resolve3();
58701
+ resolve5();
57878
58702
  });
57879
58703
  });
57880
58704
  return;
@@ -57960,8 +58784,8 @@ var Ink = class {
57960
58784
  async awaitNextRender() {
57961
58785
  if (!this.nextRenderCommit) {
57962
58786
  let resolveRender;
57963
- const promise2 = new Promise((resolve3) => {
57964
- resolveRender = resolve3;
58787
+ const promise2 = new Promise((resolve5) => {
58788
+ resolveRender = resolve5;
57965
58789
  });
57966
58790
  this.nextRenderCommit = { promise: promise2, resolve: resolveRender };
57967
58791
  }
@@ -58977,6 +59801,7 @@ async function gatherContext(request) {
58977
59801
  import { execFileSync as execFileSync2, spawn as spawn2 } from "child_process";
58978
59802
  import * as fs3 from "fs";
58979
59803
  import * as net from "net";
59804
+ import { homedir as homedir4 } from "os";
58980
59805
  import { fileURLToPath } from "url";
58981
59806
 
58982
59807
  // src/contracts/ipc.ts
@@ -58999,6 +59824,11 @@ var ipcRequestSchema = external_exports.discriminatedUnion("kind", [
58999
59824
  // The client wants one `candidate` message per parsed row before the final
59000
59825
  // `candidates` message (Phase 09.1). Old daemons strip the key and reply once.
59001
59826
  stream: external_exports.literal(true).optional()
59827
+ }),
59828
+ // Stop the daemon (WR-07): `qq init provider` restarts it without relying on `lsof`.
59829
+ // Old daemons ignore the unknown kind, so the caller falls back to signalling listeners.
59830
+ external_exports.object({
59831
+ kind: external_exports.literal("shutdown")
59002
59832
  })
59003
59833
  ]);
59004
59834
  var ipcResponseSchema = external_exports.discriminatedUnion("kind", [
@@ -59008,7 +59838,11 @@ var ipcResponseSchema = external_exports.discriminatedUnion("kind", [
59008
59838
  // Daemon accepts envelopes carrying the `installed-tools` chunk (Phase 9).
59009
59839
  installedTools: external_exports.literal(true).optional(),
59010
59840
  // Daemon streams `candidate` messages to a `stream: true` request (Phase 09.1).
59011
- streamCandidates: external_exports.literal(true).optional()
59841
+ streamCandidates: external_exports.literal(true).optional(),
59842
+ // Daemon resolves the adapter from provider.json on every fetch (Phase 8, 08-03).
59843
+ // A routing change, not an envelope shape change: a daemon without it sends every
59844
+ // prompt to Claude even when the user pinned a local provider.
59845
+ providerPin: external_exports.literal(true).optional()
59012
59846
  }),
59013
59847
  external_exports.object({
59014
59848
  kind: external_exports.literal("session-ready"),
@@ -59034,6 +59868,10 @@ var ipcResponseSchema = external_exports.discriminatedUnion("kind", [
59034
59868
  external_exports.object({
59035
59869
  kind: external_exports.literal("fetch-error"),
59036
59870
  message: external_exports.string()
59871
+ }),
59872
+ // Sent before the daemon closes its server for a `shutdown` request (WR-07).
59873
+ external_exports.object({
59874
+ kind: external_exports.literal("shutdown-accepted")
59037
59875
  })
59038
59876
  ]);
59039
59877
 
@@ -59060,25 +59898,26 @@ var CONNECT_TIMEOUT_MS = 500;
59060
59898
  var PING_TIMEOUT_MS = 500;
59061
59899
  var POLL_INTERVAL_MS = 50;
59062
59900
  var POLL_MAX_ATTEMPTS = 40;
59901
+ var SHUTDOWN_ACK_TIMEOUT_MS = 500;
59063
59902
  function tryConnect(socketPath2) {
59064
- return new Promise((resolve3) => {
59903
+ return new Promise((resolve5) => {
59065
59904
  const timer = setTimeout(() => {
59066
59905
  client.destroy();
59067
- resolve3(false);
59906
+ resolve5(false);
59068
59907
  }, CONNECT_TIMEOUT_MS);
59069
59908
  const client = net.createConnection(socketPath2, () => {
59070
59909
  clearTimeout(timer);
59071
59910
  client.destroy();
59072
- resolve3(true);
59911
+ resolve5(true);
59073
59912
  });
59074
59913
  client.on("error", () => {
59075
59914
  clearTimeout(timer);
59076
- resolve3(false);
59915
+ resolve5(false);
59077
59916
  });
59078
59917
  });
59079
59918
  }
59080
59919
  function pingDaemonFetchCap(socketPath2) {
59081
- return new Promise((resolve3) => {
59920
+ return new Promise((resolve5) => {
59082
59921
  let settled = false;
59083
59922
  let buf = "";
59084
59923
  let timer;
@@ -59091,7 +59930,7 @@ function pingDaemonFetchCap(socketPath2) {
59091
59930
  clearTimeout(timer);
59092
59931
  }
59093
59932
  client.destroy();
59094
- resolve3(result);
59933
+ resolve5(result);
59095
59934
  };
59096
59935
  const client = net.createConnection(socketPath2);
59097
59936
  timer = setTimeout(() => {
@@ -59119,7 +59958,7 @@ function pingDaemonFetchCap(socketPath2) {
59119
59958
  done("unknown");
59120
59959
  return;
59121
59960
  }
59122
- const current2 = response.data.fetchCandidates === true && response.data.installedTools === true && response.data.streamCandidates === true;
59961
+ const current2 = response.data.fetchCandidates === true && response.data.installedTools === true && response.data.streamCandidates === true && response.data.providerPin === true;
59123
59962
  done(current2 ? "yes" : "no");
59124
59963
  });
59125
59964
  client.on("error", () => {
@@ -59127,6 +59966,51 @@ function pingDaemonFetchCap(socketPath2) {
59127
59966
  });
59128
59967
  });
59129
59968
  }
59969
+ function requestDaemonShutdown(socketPath2) {
59970
+ return new Promise((resolve5) => {
59971
+ let settled = false;
59972
+ let buf = "";
59973
+ let timer;
59974
+ const done = (accepted) => {
59975
+ if (settled) {
59976
+ return;
59977
+ }
59978
+ settled = true;
59979
+ if (timer !== void 0) {
59980
+ clearTimeout(timer);
59981
+ }
59982
+ client.destroy();
59983
+ resolve5(accepted);
59984
+ };
59985
+ const client = net.createConnection(socketPath2);
59986
+ timer = setTimeout(() => {
59987
+ done(false);
59988
+ }, SHUTDOWN_ACK_TIMEOUT_MS);
59989
+ client.on("connect", () => {
59990
+ client.write(`${JSON.stringify({ kind: "shutdown" })}
59991
+ `);
59992
+ });
59993
+ client.on("data", (chunk) => {
59994
+ buf += chunk.toString();
59995
+ const nl = buf.indexOf("\n");
59996
+ if (nl === -1) {
59997
+ return;
59998
+ }
59999
+ let parsed;
60000
+ try {
60001
+ parsed = JSON.parse(buf.slice(0, nl));
60002
+ } catch {
60003
+ done(false);
60004
+ return;
60005
+ }
60006
+ const response = ipcResponseSchema.safeParse(parsed);
60007
+ done(response.success && response.data.kind === "shutdown-accepted");
60008
+ });
60009
+ client.on("error", () => {
60010
+ done(false);
60011
+ });
60012
+ });
60013
+ }
59130
60014
  async function waitForSocket(socketPath2, maxAttempts = POLL_MAX_ATTEMPTS) {
59131
60015
  for (let i = 0; i < maxAttempts; i++) {
59132
60016
  if (await tryConnect(socketPath2)) return true;
@@ -59147,10 +60031,16 @@ function listenerPids(socketPath2) {
59147
60031
  }
59148
60032
  }
59149
60033
  function sleep2(ms) {
59150
- return new Promise((resolve3) => setTimeout(resolve3, ms));
60034
+ return new Promise((resolve5) => setTimeout(resolve5, ms));
59151
60035
  }
59152
60036
  async function replaceStaleListener(socketPath2) {
59153
60037
  void appendDebugLog("daemon", "replacing stale daemon", { socketPath: socketPath2 });
60038
+ if (await requestDaemonShutdown(socketPath2)) {
60039
+ void appendDebugLog("daemon", "daemon accepted shutdown", { socketPath: socketPath2 });
60040
+ for (let i = 0; i < 20 && await tryConnect(socketPath2); i++) {
60041
+ await sleep2(50);
60042
+ }
60043
+ }
59154
60044
  for (const pid of listenerPids(socketPath2)) {
59155
60045
  try {
59156
60046
  process.kill(pid, "SIGTERM");
@@ -59188,11 +60078,30 @@ function spawnDaemon(socketPath2) {
59188
60078
  }
59189
60079
  void appendDebugLog("daemon", "spawning daemon", { qqScript, socketPath: socketPath2 });
59190
60080
  const child = spawn2(qqBin, [qqScript, "daemon", "--socket", socketPath2], {
60081
+ cwd: daemonCwd(),
59191
60082
  detached: true,
59192
60083
  stdio: "ignore"
59193
60084
  });
60085
+ child.on("error", (error43) => {
60086
+ void appendDebugLog("daemon", "spawn failed", { code: error43.code });
60087
+ });
59194
60088
  child.unref();
59195
60089
  }
60090
+ function daemonCwd() {
60091
+ const home = homedir4();
60092
+ return home && fs3.existsSync(home) ? home : "/";
60093
+ }
60094
+ async function restartDaemon(socketPath2) {
60095
+ assertSafeSocketPath(socketPath2);
60096
+ void appendDebugLog("daemon", "restart requested", { socketPath: socketPath2 });
60097
+ await replaceStaleListener(socketPath2);
60098
+ spawnDaemon(socketPath2);
60099
+ if (!await waitForSocket(socketPath2)) {
60100
+ void appendDebugLog("daemon", "restart timeout", { socketPath: socketPath2 });
60101
+ throw new Error("qq daemon did not restart within the expected window");
60102
+ }
60103
+ void appendDebugLog("daemon", "daemon ready", { socketPath: socketPath2, restarted: true });
60104
+ }
59196
60105
  async function ensureDaemon(socketPath2) {
59197
60106
  assertSafeSocketPath(socketPath2);
59198
60107
  void appendDebugLog("daemon", "ensure start", { socketPath: socketPath2 });
@@ -59220,18 +60129,6 @@ async function ensureDaemon(socketPath2) {
59220
60129
 
59221
60130
  // src/daemon/fetch-client.ts
59222
60131
  import * as net2 from "net";
59223
-
59224
- // src/providers/resolver.ts
59225
- var MISSING_ADAPTER_MESSAGE = "QueQue: Claude provider is not registered \u2014 was bootstrapBuiltins() called?";
59226
- function resolveClaudeDefaultAdapter() {
59227
- const adapter = getProviderAdapter("claude-cli");
59228
- if (!adapter) {
59229
- throw new Error(MISSING_ADAPTER_MESSAGE);
59230
- }
59231
- return adapter;
59232
- }
59233
-
59234
- // src/daemon/fetch-client.ts
59235
60132
  var FETCH_ACK_MS = 800;
59236
60133
  var FETCH_TIMEOUT_MS = 26e3;
59237
60134
  var IpcTransportError = class extends Error {
@@ -59245,7 +60142,7 @@ function requestDaemonFetch(socketPath2, envelope, timeoutMs = FETCH_TIMEOUT_MS,
59245
60142
  if (signal?.aborted) {
59246
60143
  return Promise.reject(abortError());
59247
60144
  }
59248
- return new Promise((resolve3, reject) => {
60145
+ return new Promise((resolve5, reject) => {
59249
60146
  const client = net2.createConnection(socketPath2);
59250
60147
  let buf = "";
59251
60148
  let settled = false;
@@ -59266,7 +60163,7 @@ function requestDaemonFetch(socketPath2, envelope, timeoutMs = FETCH_TIMEOUT_MS,
59266
60163
  reject(error43);
59267
60164
  return;
59268
60165
  }
59269
- resolve3(candidates);
60166
+ resolve5(candidates);
59270
60167
  };
59271
60168
  const ackTimer = setTimeout(() => {
59272
60169
  if (!accepted) {
@@ -59366,7 +60263,7 @@ async function fetchCandidatesForUi(socketPath2, envelope, options = {}) {
59366
60263
  throw error43;
59367
60264
  }
59368
60265
  void appendDebugLog("client", "daemon fetch fallback", { message: error43.message });
59369
- return resolveClaudeDefaultAdapter().fetchCandidates(envelope, options);
60266
+ return resolveProviderAdapter().fetchCandidates(envelope, options);
59370
60267
  }
59371
60268
  }
59372
60269
 
@@ -60433,7 +61330,7 @@ function CandidateSelect({
60433
61330
  /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Text, { dimColor: true, children: legend.slice(MISSING_TOOL_MARK.length) })
60434
61331
  ] }),
60435
61332
  /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(ControlsLine, {}),
60436
- process.env.QQ_DEV_ROOT != null && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Box_default, { justifyContent: "flex-end", children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Text, { color: "yellow", children: `dev v${"0.6.1"} ${"1a2baf5"}` }) })
61333
+ process.env.QQ_DEV_ROOT != null && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Box_default, { justifyContent: "flex-end", children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Text, { color: "yellow", children: `dev v${"0.7.1"} ${"d3db9b9"}` }) })
60437
61334
  ] });
60438
61335
  }
60439
61336
 
@@ -60711,8 +61608,14 @@ async function runForegroundClient(args) {
60711
61608
  shellPid: request.shellPid
60712
61609
  });
60713
61610
  const toolInventory = resultMode === "llm" ? await readToolHandoff(path4.dirname(requestFile)) : null;
60714
- await ensureDaemon(socketPath2);
60715
- void appendDebugLog("client", "daemon ensured", { socketPath: socketPath2 });
61611
+ try {
61612
+ await ensureDaemon(socketPath2);
61613
+ void appendDebugLog("client", "daemon ensured", { socketPath: socketPath2 });
61614
+ } catch (error43) {
61615
+ void appendDebugLog("client", "daemon ensure failed", {
61616
+ message: error43 instanceof Error ? error43.message : String(error43)
61617
+ });
61618
+ }
60716
61619
  if (resultMode === "replace-buffer-fixture") {
60717
61620
  const fixtureLbuffer = request.lbuffer || "echo hello";
60718
61621
  await writeShellResult(resultFile, {
@@ -60780,7 +61683,7 @@ async function runForegroundClient(args) {
60780
61683
  void appendDebugLog("client", "context gathered", {
60781
61684
  extraCount: envelope.extras.length
60782
61685
  });
60783
- await new Promise((resolve3) => {
61686
+ await new Promise((resolve5) => {
60784
61687
  let unmount;
60785
61688
  let resolved = false;
60786
61689
  const fetchAbort = new AbortController();
@@ -60835,7 +61738,7 @@ async function runForegroundClient(args) {
60835
61738
  process.off("SIGTERM", cleanupOnSignal);
60836
61739
  app.unmount();
60837
61740
  if (!skipClear) clearScrollReserve();
60838
- resolve3();
61741
+ resolve5();
60839
61742
  };
60840
61743
  const onCandidate = (candidate) => {
60841
61744
  if (resolved) return;
@@ -60929,8 +61832,8 @@ async function clientCommand(options) {
60929
61832
 
60930
61833
  // src/daemon/server.ts
60931
61834
  import * as net3 from "net";
60932
- function startDaemonServer(socketPath2) {
60933
- return new Promise((resolve3, reject) => {
61835
+ function startDaemonServer(socketPath2, options = {}) {
61836
+ return new Promise((resolve5, reject) => {
60934
61837
  const MAX_BUF_BYTES = 256 * 1024;
60935
61838
  const server = net3.createServer((socket) => {
60936
61839
  let buf = "";
@@ -60975,11 +61878,25 @@ function startDaemonServer(socketPath2) {
60975
61878
  kind: "pong",
60976
61879
  fetchCandidates: true,
60977
61880
  installedTools: true,
60978
- streamCandidates: true
61881
+ streamCandidates: true,
61882
+ providerPin: true
60979
61883
  });
60980
61884
  void appendDebugLog("daemon", "replied pong");
60981
61885
  break;
60982
61886
  }
61887
+ case "shutdown": {
61888
+ const { onShutdown } = options;
61889
+ if (!onShutdown) {
61890
+ void appendDebugLog("daemon", "ignored shutdown request");
61891
+ break;
61892
+ }
61893
+ void appendDebugLog("daemon", "shutdown requested");
61894
+ socket.write(`${JSON.stringify({ kind: "shutdown-accepted" })}
61895
+ `, () => {
61896
+ onShutdown();
61897
+ });
61898
+ break;
61899
+ }
60983
61900
  case "ensure-session": {
60984
61901
  writeJson({ kind: "session-ready", socketPath: socketPath2 });
60985
61902
  void appendDebugLog("daemon", "replied session-ready", { socketPath: socketPath2 });
@@ -61010,7 +61927,7 @@ function startDaemonServer(socketPath2) {
61010
61927
  } : void 0;
61011
61928
  void Promise.resolve().then(() => {
61012
61929
  bootstrapBuiltins();
61013
- const adapter = resolveClaudeDefaultAdapter();
61930
+ const adapter = resolveProviderAdapter();
61014
61931
  return adapter.fetchCandidates(envelope, {
61015
61932
  signal: connectionAbort.signal,
61016
61933
  onCandidate
@@ -61047,7 +61964,7 @@ function startDaemonServer(socketPath2) {
61047
61964
  server.on("error", reject);
61048
61965
  server.listen(socketPath2, () => {
61049
61966
  void appendDebugLog("daemon", "listening", { socketPath: socketPath2 });
61050
- resolve3(server);
61967
+ resolve5(server);
61051
61968
  });
61052
61969
  });
61053
61970
  }
@@ -61087,7 +62004,8 @@ async function daemonCommand(options) {
61087
62004
  void appendDebugLog("daemon", "ensure command complete", { socket: sock });
61088
62005
  return;
61089
62006
  }
61090
- const server = await startDaemonServer(sock);
62007
+ let onShutdownRequest = () => void 0;
62008
+ const server = await startDaemonServer(sock, { onShutdown: () => onShutdownRequest() });
61091
62009
  const connections = trackConnections(server);
61092
62010
  void appendDebugLog("daemon", "server started", { socket: sock });
61093
62011
  enablePrewarm();
@@ -61095,25 +62013,33 @@ async function daemonCommand(options) {
61095
62013
  void appendDebugLog("daemon", "shutdown", { socket: sock, inFlight: connections.size });
61096
62014
  shutdownDaemon(server, connections);
61097
62015
  };
62016
+ onShutdownRequest = shutdown;
61098
62017
  process.once("SIGTERM", shutdown);
61099
62018
  process.once("SIGINT", shutdown);
61100
62019
  await new Promise(() => {
61101
62020
  });
61102
62021
  }
61103
62022
 
62023
+ // src/cli/commands/init-provider.ts
62024
+ import { spawn as spawn4 } from "child_process";
62025
+ import { closeSync, openSync } from "fs";
62026
+ import { homedir as homedir6 } from "os";
62027
+ import { createInterface } from "readline";
62028
+ import * as tty4 from "tty";
62029
+
61104
62030
  // src/cli/commands/init.ts
61105
- import { appendFileSync, existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
61106
- import { homedir as homedir2 } from "os";
61107
- import { dirname as dirname4, join as join4, resolve as resolve2 } from "path";
62031
+ import { appendFileSync, existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
62032
+ import { homedir as homedir5 } from "os";
62033
+ import { dirname as dirname5, join as join5, resolve as resolve4 } from "path";
61108
62034
  import { fileURLToPath as fileURLToPath2 } from "url";
61109
- var __dirname = dirname4(fileURLToPath2(import.meta.url));
62035
+ var __dirname = dirname5(fileURLToPath2(import.meta.url));
61110
62036
  var HOMEBREW_PREFIXES = ["/opt/homebrew", "/usr/local", "/home/linuxbrew/.linuxbrew"];
61111
62037
  function _resolveScriptPath(shell) {
61112
62038
  for (const prefix of HOMEBREW_PREFIXES) {
61113
- const p = resolve2(prefix, "share", "queque", `queque.${shell}`);
62039
+ const p = resolve4(prefix, "share", "queque", `queque.${shell}`);
61114
62040
  if (existsSync4(p)) return p;
61115
62041
  }
61116
- return resolve2(__dirname, "../../shell", shell, `queque.${shell}`);
62042
+ return resolve4(__dirname, "../../shell", shell, `queque.${shell}`);
61117
62043
  }
61118
62044
  function hasShellIntegration(existing, shell) {
61119
62045
  if (/# queque shell integration/.test(existing)) {
@@ -61129,10 +62055,10 @@ function initCommand(shell) {
61129
62055
  console.error(`Unsupported shell: '${shell}'. Supported: ${supportedShells.join(", ")}`);
61130
62056
  process.exit(1);
61131
62057
  }
61132
- const zshrc = join4(homedir2(), ".zshrc");
62058
+ const zshrc = join5(homedir5(), ".zshrc");
61133
62059
  const scriptPath = _resolveScriptPath(shell);
61134
62060
  const snippet = `source "${scriptPath}"`;
61135
- const existing = existsSync4(zshrc) ? readFileSync4(zshrc, "utf8") : "";
62061
+ const existing = existsSync4(zshrc) ? readFileSync5(zshrc, "utf8") : "";
61136
62062
  if (hasShellIntegration(existing, shell)) {
61137
62063
  console.error("queque: shell integration already present in ~/.zshrc");
61138
62064
  process.exit(0);
@@ -61144,6 +62070,306 @@ ${snippet}
61144
62070
  console.log("queque: added shell integration to ~/.zshrc \u2014 run: source ~/.zshrc");
61145
62071
  }
61146
62072
 
62073
+ // src/cli/commands/init-provider.ts
62074
+ var PROVIDER_MENU = [
62075
+ {
62076
+ id: "claude",
62077
+ label: "Claude",
62078
+ hint: "Claude Code (`claude /login`) or ANTHROPIC_API_KEY"
62079
+ },
62080
+ { id: "openai", label: "OpenAI (beta)", hint: "uses OPENAI_API_KEY" },
62081
+ { id: "ollama", label: "Ollama (beta)", hint: "local models on this machine" }
62082
+ ];
62083
+ var MENU_LABEL_WIDTH = Math.max(...PROVIDER_MENU.map((entry) => entry.label.length));
62084
+ var OLLAMA_DOWNLOAD_URL = "https://ollama.com/download";
62085
+ var MAX_ATTEMPTS = 3;
62086
+ var MAX_REASON = 120;
62087
+ var NO_CHANGES = "No changes made.";
62088
+ var CLAUDE_AUTH_HINT = "If ?? says Claude is not authenticated, run `claude /login` or set ANTHROPIC_API_KEY (docs: https://code.claude.com/docs/en/authentication).";
62089
+ var OPENAI_KEY_MISSING = "OPENAI_API_KEY is not set. Add `export OPENAI_API_KEY=...` to ~/.zshrc (before the queque source line) or put it in ~/.env.local, open a new terminal, and run `qq init provider` again.";
62090
+ function openDownloadUrl(url2) {
62091
+ if (url2 !== OLLAMA_DOWNLOAD_URL) {
62092
+ return;
62093
+ }
62094
+ const opener = process.platform === "darwin" ? "open" : "xdg-open";
62095
+ try {
62096
+ const child = spawn4(opener, [url2], { stdio: "ignore", detached: true });
62097
+ child.on("error", () => void 0);
62098
+ child.unref();
62099
+ } catch {
62100
+ }
62101
+ }
62102
+ var defaultDeps = {
62103
+ openUrl: openDownloadUrl,
62104
+ restartDaemon: (path5) => restartDaemon(path5),
62105
+ listOllamaModels: (baseUrl) => listOllamaModels(baseUrl)
62106
+ };
62107
+ function shortReason(error43) {
62108
+ const code = error43?.code;
62109
+ const message = error43 instanceof Error ? error43.message : String(error43);
62110
+ const flat = (typeof code === "string" ? code : message).replace(/\s+/g, " ").trim();
62111
+ return flat.length > MAX_REASON ? `${flat.slice(0, MAX_REASON)}\u2026` : flat;
62112
+ }
62113
+ function choiceHint(count) {
62114
+ if (count === 1) {
62115
+ return "Choose 1.";
62116
+ }
62117
+ if (count === 2) {
62118
+ return "Choose 1 or 2.";
62119
+ }
62120
+ if (count === 3) {
62121
+ return "Choose 1, 2, or 3.";
62122
+ }
62123
+ return `Choose a number from 1 to ${count}.`;
62124
+ }
62125
+ var Prompter = class {
62126
+ constructor(io) {
62127
+ this.io = io;
62128
+ this.rl = createInterface({
62129
+ input: io.input,
62130
+ terminal: false,
62131
+ crlfDelay: Number.POSITIVE_INFINITY
62132
+ });
62133
+ this.lines = this.rl[Symbol.asyncIterator]();
62134
+ }
62135
+ io;
62136
+ rl;
62137
+ lines;
62138
+ say(line) {
62139
+ this.io.output.write(`${line}
62140
+ `);
62141
+ }
62142
+ /** The trimmed answer, or null when the input ended (or closed) first. */
62143
+ async ask(prompt) {
62144
+ this.io.output.write(prompt);
62145
+ try {
62146
+ const next = await this.lines.next();
62147
+ return next.done ? null : String(next.value).trim();
62148
+ } catch {
62149
+ return null;
62150
+ }
62151
+ }
62152
+ /** A 1-based choice where Enter picks 1; re-asks up to MAX_ATTEMPTS times. */
62153
+ async choose(prompt, count) {
62154
+ for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
62155
+ const answer = await this.ask(prompt);
62156
+ if (answer === null) {
62157
+ return { kind: "eof" };
62158
+ }
62159
+ if (answer === "") {
62160
+ return { kind: "choice", value: 1 };
62161
+ }
62162
+ const value = /^\d+$/.test(answer) ? Number.parseInt(answer, 10) : Number.NaN;
62163
+ if (value >= 1 && value <= count) {
62164
+ return { kind: "choice", value };
62165
+ }
62166
+ this.say(choiceHint(count));
62167
+ }
62168
+ return { kind: "invalid" };
62169
+ }
62170
+ close() {
62171
+ this.rl.close();
62172
+ }
62173
+ };
62174
+ function describeCurrent(prompter, state) {
62175
+ if (state.kind === "pinned") {
62176
+ const { pin } = state;
62177
+ const model = "model" in pin && pin.model ? ` (${pin.model})` : "";
62178
+ prompter.say(`Current: ${pin.provider}${model}`);
62179
+ } else if (state.kind === "invalid") {
62180
+ prompter.say("Current provider.json is invalid; your choice below replaces it.");
62181
+ }
62182
+ }
62183
+ function openAiKeyPresent() {
62184
+ return (usableSecret(process.env.OPENAI_API_KEY) ?? usableSecret(readEnvValueFromDotEnvLocal("OPENAI_API_KEY", homedir6()))) !== void 0;
62185
+ }
62186
+ function keptPinFields(state) {
62187
+ if (state.kind !== "pinned") {
62188
+ return {};
62189
+ }
62190
+ const { pin } = state;
62191
+ if (pin.provider === "ollama" && pin.baseUrl) {
62192
+ return { ollamaBaseUrl: pin.baseUrl };
62193
+ }
62194
+ if (pin.provider === "openai" && pin.model) {
62195
+ return { openAiModel: pin.model };
62196
+ }
62197
+ return {};
62198
+ }
62199
+ async function explainOllamaDown(prompter, deps, baseUrl, savedBaseUrl) {
62200
+ prompter.say(`Ollama is not answering at ${baseUrl}.`);
62201
+ if (savedBaseUrl) {
62202
+ prompter.say(
62203
+ `Check that the Ollama server at ${baseUrl} is running, or remove "baseUrl" from ${providerPinPath()} to use Ollama on this machine, then run \`qq init provider\` again.`
62204
+ );
62205
+ return;
62206
+ }
62207
+ prompter.say(
62208
+ `Install it from ${OLLAMA_DOWNLOAD_URL}, start it with \`ollama serve\`, then run \`qq init provider\` again.`
62209
+ );
62210
+ const answer = await prompter.ask(`Open ${OLLAMA_DOWNLOAD_URL} in your browser? [y/N]: `);
62211
+ if (answer !== null && /^(y|yes)$/i.test(answer)) {
62212
+ deps.openUrl(OLLAMA_DOWNLOAD_URL);
62213
+ }
62214
+ }
62215
+ async function pickOllamaModel(prompter, deps, savedBaseUrl) {
62216
+ const baseUrl = savedBaseUrl ?? OLLAMA_DEFAULT_BASE_URL;
62217
+ const listed = await deps.listOllamaModels(baseUrl);
62218
+ if (!listed.ok) {
62219
+ await explainOllamaDown(prompter, deps, baseUrl, savedBaseUrl !== void 0);
62220
+ return null;
62221
+ }
62222
+ const { models } = listed;
62223
+ if (models.length === 0) {
62224
+ prompter.say(
62225
+ "Ollama is running but has no models. Run `ollama pull gemma4` (or any model), then run `qq init provider` again."
62226
+ );
62227
+ return null;
62228
+ }
62229
+ prompter.say("Installed Ollama models:");
62230
+ models.forEach((model, index) => {
62231
+ prompter.say(` ${index + 1}. ${model}`);
62232
+ });
62233
+ const choice = await prompter.choose(`Model 1-${models.length} [1]: `, models.length);
62234
+ if (choice.kind !== "choice") {
62235
+ prompter.say(NO_CHANGES);
62236
+ return null;
62237
+ }
62238
+ return models[choice.value - 1];
62239
+ }
62240
+ function savePin(prompter, pin) {
62241
+ try {
62242
+ return writeProviderPin(pin);
62243
+ } catch (error43) {
62244
+ prompter.say(`Could not save ${providerPinPath()} (${shortReason(error43)}). ${NO_CHANGES}`);
62245
+ return null;
62246
+ }
62247
+ }
62248
+ async function refreshDaemon(prompter, deps) {
62249
+ try {
62250
+ await deps.restartDaemon(socketPath());
62251
+ prompter.say(
62252
+ "Restarted the QueQue daemon so the next ?? uses this provider and your current environment."
62253
+ );
62254
+ } catch (error43) {
62255
+ prompter.say(
62256
+ `Pin saved, but the QueQue daemon could not restart (${shortReason(error43)}). Open a new terminal before the next ??.`
62257
+ );
62258
+ }
62259
+ }
62260
+ async function pickAndSave(prompter, deps) {
62261
+ prompter.say("QueQue provider setup");
62262
+ const current2 = loadProviderPin();
62263
+ describeCurrent(prompter, current2);
62264
+ const kept = keptPinFields(current2);
62265
+ PROVIDER_MENU.forEach((entry, index) => {
62266
+ prompter.say(` ${index + 1}. ${entry.label.padEnd(MENU_LABEL_WIDTH)} ${entry.hint}`);
62267
+ });
62268
+ const choice = await prompter.choose(
62269
+ `Choose 1-${PROVIDER_MENU.length} [1]: `,
62270
+ PROVIDER_MENU.length
62271
+ );
62272
+ if (choice.kind !== "choice") {
62273
+ prompter.say(NO_CHANGES);
62274
+ return 1;
62275
+ }
62276
+ const provider = PROVIDER_MENU[choice.value - 1].id;
62277
+ if (provider === "claude") {
62278
+ const path5 = savePin(prompter, { version: 1, provider: "claude" });
62279
+ if (path5 === null) {
62280
+ return 1;
62281
+ }
62282
+ prompter.say(`Saved ${path5}: Claude.`);
62283
+ prompter.say(CLAUDE_AUTH_HINT);
62284
+ } else if (provider === "openai") {
62285
+ if (!openAiKeyPresent()) {
62286
+ prompter.say(OPENAI_KEY_MISSING);
62287
+ return 1;
62288
+ }
62289
+ const { openAiModel } = kept;
62290
+ const path5 = savePin(prompter, {
62291
+ version: 1,
62292
+ provider: "openai",
62293
+ ...openAiModel ? { model: openAiModel } : {}
62294
+ });
62295
+ if (path5 === null) {
62296
+ return 1;
62297
+ }
62298
+ prompter.say(
62299
+ openAiModel ? `Saved ${path5}: OpenAI (kept model ${openAiModel}).` : `Saved ${path5}: OpenAI (default model; add "model" to provider.json to change it).`
62300
+ );
62301
+ } else {
62302
+ const { ollamaBaseUrl } = kept;
62303
+ const model = await pickOllamaModel(prompter, deps, ollamaBaseUrl);
62304
+ if (model === null) {
62305
+ return 1;
62306
+ }
62307
+ const path5 = savePin(prompter, {
62308
+ version: 1,
62309
+ provider: "ollama",
62310
+ model,
62311
+ ...ollamaBaseUrl ? { baseUrl: ollamaBaseUrl } : {}
62312
+ });
62313
+ if (path5 === null) {
62314
+ return 1;
62315
+ }
62316
+ prompter.say(
62317
+ ollamaBaseUrl ? `Saved ${path5}: Ollama (${model}) at ${ollamaBaseUrl}.` : `Saved ${path5}: Ollama (${model}). Using a remote Ollama? Add "baseUrl" to provider.json.`
62318
+ );
62319
+ }
62320
+ await refreshDaemon(prompter, deps);
62321
+ return 0;
62322
+ }
62323
+ async function runProviderPicker(io, deps = {}) {
62324
+ const prompter = new Prompter(io);
62325
+ try {
62326
+ return await pickAndSave(prompter, { ...defaultDeps, ...deps });
62327
+ } finally {
62328
+ prompter.close();
62329
+ }
62330
+ }
62331
+ function endStream(stream) {
62332
+ return new Promise((resolve5) => {
62333
+ stream.end(() => resolve5());
62334
+ });
62335
+ }
62336
+ function openTerminal() {
62337
+ let inFd;
62338
+ try {
62339
+ inFd = openSync("/dev/tty", "r");
62340
+ return { inFd, outFd: openSync("/dev/tty", "w") };
62341
+ } catch {
62342
+ if (inFd !== void 0) {
62343
+ closeSync(inFd);
62344
+ }
62345
+ return null;
62346
+ }
62347
+ }
62348
+ async function providerInitCommand() {
62349
+ const terminal = openTerminal();
62350
+ if (terminal === null) {
62351
+ console.error("qq init provider needs an interactive terminal (/dev/tty).");
62352
+ process.exitCode = 1;
62353
+ return;
62354
+ }
62355
+ const input = new tty4.ReadStream(terminal.inFd);
62356
+ const output = new tty4.WriteStream(terminal.outFd);
62357
+ try {
62358
+ process.exitCode = await runProviderPicker({ input, output });
62359
+ } finally {
62360
+ input.destroy();
62361
+ await endStream(output);
62362
+ output.destroy();
62363
+ }
62364
+ }
62365
+ async function dispatchInit(shell, handlers = { provider: providerInitCommand, shell: initCommand }) {
62366
+ if (shell === "provider") {
62367
+ await handlers.provider();
62368
+ return;
62369
+ }
62370
+ handlers.shell(shell);
62371
+ }
62372
+
61147
62373
  // src/cli/main.ts
61148
62374
  function requiredOption(name, value) {
61149
62375
  if (!value) {
@@ -61186,9 +62412,9 @@ async function main(argv = process.argv.slice(2)) {
61186
62412
  });
61187
62413
  cli.command(
61188
62414
  "init <shell>",
61189
- "Add shell integration to ~/.zshrc (run `qq init zsh && source ~/.zshrc`)"
61190
- ).action((shell) => {
61191
- initCommand(shell);
62415
+ "Add shell integration to ~/.zshrc (`qq init zsh && source ~/.zshrc`), or run `qq init provider` to pick OpenAI or Ollama"
62416
+ ).action(async (shell) => {
62417
+ await dispatchInit(shell);
61192
62418
  });
61193
62419
  cli.command("daemon").option("--socket <path>", "Unix socket path for the daemon").option("--ensure", "Ensure the daemon is running before returning").action(async (options) => {
61194
62420
  await daemonCommand(options);