@dexto/tui 1.6.2

package/dist/utils/commandOverlays.js

@@ -0,0 +1,44 @@
+const ALWAYS_OVERLAY = {
+  search: "search",
+  find: "search",
+  // alias
+  login: "login",
+  logout: "logout",
+  model: "model-selector",
+  reasoning: "reasoning",
+  resume: "session-selector",
+  switch: "session-selector",
+  stream: "stream-selector",
+  sounds: "sounds-selector",
+  tools: "tool-browser",
+  mcp: "mcp-server-list",
+  rename: "session-rename",
+  context: "context-stats",
+  ctx: "context-stats",
+  // alias
+  tokens: "context-stats",
+  // alias
+  export: "export-wizard",
+  plugin: "plugin-manager"
+};
+const NO_ARGS_OVERLAY = {
+  session: "session-subcommand-selector",
+  log: "log-level-selector",
+  prompts: "prompt-list"
+};
+function getCommandOverlay(command, args) {
+  const alwaysOverlay = ALWAYS_OVERLAY[command];
+  if (alwaysOverlay) return alwaysOverlay;
+  if (args.length === 0) {
+    const noArgsOverlay = NO_ARGS_OVERLAY[command];
+    if (noArgsOverlay) return noArgsOverlay;
+  }
+  return null;
+}
+function isInteractiveCommand(command) {
+  return command in ALWAYS_OVERLAY || command in NO_ARGS_OVERLAY;
+}
+export {
+  getCommandOverlay,
+  isInteractiveCommand
+};

package/dist/utils/debugLog.cjs

@@ -0,0 +1,63 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var debugLog_exports = {};
+__export(debugLog_exports, {
+  createDebugLogger: () => createDebugLogger
+});
+module.exports = __toCommonJS(debugLog_exports);
+var import_fs = require("fs");
+var import_os = require("os");
+var import_path = require("path");
+function createDebugLogger(name) {
+  const envVar = `DEXTO_DEBUG_${name.toUpperCase()}`;
+  const logPath = (0, import_path.join)((0, import_os.tmpdir)(), `dexto-debug-${name.toLowerCase()}.log`);
+  const isEnabled = () => {
+    return process.env[envVar] === "true" || process.env.DEXTO_DEBUG_ALL === "true";
+  };
+  const log = (msg, data) => {
+    if (!isEnabled()) return;
+    try {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[1];
+      const dataStr = data ? ` ${JSON.stringify(data)}` : "";
+      const line = `[${timestamp}] ${msg}${dataStr}
+`;
+      (0, import_fs.appendFileSync)(logPath, line);
+    } catch {
+    }
+  };
+  const reset = (header) => {
+    if (!isEnabled()) return;
+    const defaultHeader = `=== DEXTO DEBUG [${name.toUpperCase()}] ${(/* @__PURE__ */ new Date()).toISOString()} ===`;
+    try {
+      (0, import_fs.writeFileSync)(logPath, `${header ?? defaultHeader}
+`);
+    } catch {
+    }
+  };
+  return {
+    log,
+    isEnabled,
+    getLogPath: () => logPath,
+    reset
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDebugLogger
+});

package/dist/utils/debugLog.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Debug Logging Utility
+ *
+ * Cross-platform debug logging that writes to temp directory.
+ * Controlled via environment variables for easy enable/disable.
+ *
+ * Usage:
+ *   import { createDebugLogger } from './debugLog.js';
+ *   const debug = createDebugLogger('stream');
+ *   debug.log('EVENT', { foo: 'bar' });
+ *
+ * Enable via environment:
+ *   DEXTO_DEBUG_STREAM=true dexto
+ *   DEXTO_DEBUG_ALL=true dexto  (enables all debug loggers)
+ */
+export interface DebugLogger {
+    /** Log a message with optional data */
+    log: (msg: string, data?: Record<string, unknown>) => void;
+    /** Check if debug logging is enabled */
+    isEnabled: () => boolean;
+    /** Get the log file path */
+    getLogPath: () => string;
+    /** Clear the log file and write a header */
+    reset: (header?: string) => void;
+}
+/**
+ * Creates a debug logger for a specific component.
+ *
+ * @param name Component name (used in env var and filename)
+ * @returns Debug logger instance
+ *
+ * @example
+ * const debug = createDebugLogger('stream');
+ * // Enabled via DEXTO_DEBUG_STREAM=true or DEXTO_DEBUG_ALL=true
+ * // Writes to: {tmpdir}/dexto-debug-stream.log
+ */
+export declare function createDebugLogger(name: string): DebugLogger;
+//# sourceMappingURL=debugLog.d.ts.map

package/dist/utils/debugLog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debugLog.d.ts","sourceRoot":"","sources":["../../src/utils/debugLog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,MAAM,WAAW,WAAW;IACxB,uCAAuC;IACvC,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IAC3D,wCAAwC;IACxC,SAAS,EAAE,MAAM,OAAO,CAAC;IACzB,4BAA4B;IAC5B,UAAU,EAAE,MAAM,MAAM,CAAC;IACzB,4CAA4C;IAC5C,KAAK,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CACpC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAsC3D"}

package/dist/utils/debugLog.js

@@ -0,0 +1,39 @@
+import { appendFileSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+function createDebugLogger(name) {
+  const envVar = `DEXTO_DEBUG_${name.toUpperCase()}`;
+  const logPath = join(tmpdir(), `dexto-debug-${name.toLowerCase()}.log`);
+  const isEnabled = () => {
+    return process.env[envVar] === "true" || process.env.DEXTO_DEBUG_ALL === "true";
+  };
+  const log = (msg, data) => {
+    if (!isEnabled()) return;
+    try {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[1];
+      const dataStr = data ? ` ${JSON.stringify(data)}` : "";
+      const line = `[${timestamp}] ${msg}${dataStr}
+`;
+      appendFileSync(logPath, line);
+    } catch {
+    }
+  };
+  const reset = (header) => {
+    if (!isEnabled()) return;
+    const defaultHeader = `=== DEXTO DEBUG [${name.toUpperCase()}] ${(/* @__PURE__ */ new Date()).toISOString()} ===`;
+    try {
+      writeFileSync(logPath, `${header ?? defaultHeader}
+`);
+    } catch {
+    }
+  };
+  return {
+    log,
+    isEnabled,
+    getLogPath: () => logPath,
+    reset
+  };
+}
+export {
+  createDebugLogger
+};

package/dist/utils/elicitationSchema.cjs

@@ -0,0 +1,85 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var elicitationSchema_exports = {};
+__export(elicitationSchema_exports, {
+  parseElicitationSchema: () => parseElicitationSchema
+});
+module.exports = __toCommonJS(elicitationSchema_exports);
+function humanizeIdentifier(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function titleCaseWords(value) {
+  return value.split(" ").map((word) => word ? word.charAt(0).toUpperCase() + word.slice(1) : "").join(" ");
+}
+function cleanLabel(value) {
+  return value.replace(/^\s*\d+\s*[).:-]\s*/g, "").replace(/\s*[:*]\s*$/g, "").trim();
+}
+function makeLabel(name) {
+  return titleCaseWords(humanizeIdentifier(name)) || name;
+}
+function getXDextoStepLabel(prop) {
+  const xDexto = prop["x-dexto"];
+  if (!xDexto || typeof xDexto !== "object" || Array.isArray(xDexto)) return void 0;
+  const stepLabel = xDexto.stepLabel;
+  if (typeof stepLabel !== "string") return void 0;
+  return cleanLabel(stepLabel) || void 0;
+}
+function getFieldType(prop) {
+  const { type } = prop;
+  if (type === "boolean") return { type: "boolean", enumValues: void 0 };
+  if (type === "number" || type === "integer") return { type: "number", enumValues: void 0 };
+  if (type === "array" && prop.items && Array.isArray(prop.items.enum)) {
+    return { type: "array-enum", enumValues: prop.items.enum };
+  }
+  if (Array.isArray(prop.enum)) return { type: "enum", enumValues: prop.enum };
+  return { type: "string", enumValues: void 0 };
+}
+function parseElicitationSchema(schema) {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) return [];
+  const schemaRecord = schema;
+  const properties = schemaRecord.properties;
+  if (!properties || typeof properties !== "object" || Array.isArray(properties)) return [];
+  const required = Array.isArray(schemaRecord.required) ? schemaRecord.required.filter((v) => typeof v === "string") : [];
+  const result = [];
+  for (const [name, rawProp] of Object.entries(properties)) {
+    if (typeof rawProp === "boolean" || !rawProp || typeof rawProp !== "object" || Array.isArray(rawProp)) {
+      continue;
+    }
+    const prop = rawProp;
+    const { type, enumValues } = getFieldType(prop);
+    const fallbackLabel = makeLabel(name);
+    const stepLabel = getXDextoStepLabel(prop) || fallbackLabel;
+    const question = (prop.title ? cleanLabel(prop.title) : "") || fallbackLabel;
+    const helpText = (prop.description ? cleanLabel(prop.description) : "") || void 0;
+    result.push({
+      name,
+      stepLabel,
+      question,
+      helpText,
+      type,
+      required: required.includes(name),
+      enumValues
+    });
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseElicitationSchema
+});

package/dist/utils/elicitationSchema.d.ts

@@ -0,0 +1,11 @@
+export interface ElicitationFormField {
+    name: string;
+    stepLabel: string;
+    question: string;
+    helpText: string | undefined;
+    type: 'string' | 'number' | 'boolean' | 'enum' | 'array-enum';
+    required: boolean;
+    enumValues: unknown[] | undefined;
+}
+export declare function parseElicitationSchema(schema: unknown): ElicitationFormField[];
+//# sourceMappingURL=elicitationSchema.d.ts.map

package/dist/utils/elicitationSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elicitationSchema.d.ts","sourceRoot":"","sources":["../../src/utils/elicitationSchema.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,oBAAoB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,YAAY,CAAC;IAC9D,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,EAAE,OAAO,EAAE,GAAG,SAAS,CAAC;CACrC;AAyDD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,GAAG,oBAAoB,EAAE,CA2C9E"}

package/dist/utils/elicitationSchema.js

@@ -0,0 +1,61 @@
+function humanizeIdentifier(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function titleCaseWords(value) {
+  return value.split(" ").map((word) => word ? word.charAt(0).toUpperCase() + word.slice(1) : "").join(" ");
+}
+function cleanLabel(value) {
+  return value.replace(/^\s*\d+\s*[).:-]\s*/g, "").replace(/\s*[:*]\s*$/g, "").trim();
+}
+function makeLabel(name) {
+  return titleCaseWords(humanizeIdentifier(name)) || name;
+}
+function getXDextoStepLabel(prop) {
+  const xDexto = prop["x-dexto"];
+  if (!xDexto || typeof xDexto !== "object" || Array.isArray(xDexto)) return void 0;
+  const stepLabel = xDexto.stepLabel;
+  if (typeof stepLabel !== "string") return void 0;
+  return cleanLabel(stepLabel) || void 0;
+}
+function getFieldType(prop) {
+  const { type } = prop;
+  if (type === "boolean") return { type: "boolean", enumValues: void 0 };
+  if (type === "number" || type === "integer") return { type: "number", enumValues: void 0 };
+  if (type === "array" && prop.items && Array.isArray(prop.items.enum)) {
+    return { type: "array-enum", enumValues: prop.items.enum };
+  }
+  if (Array.isArray(prop.enum)) return { type: "enum", enumValues: prop.enum };
+  return { type: "string", enumValues: void 0 };
+}
+function parseElicitationSchema(schema) {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) return [];
+  const schemaRecord = schema;
+  const properties = schemaRecord.properties;
+  if (!properties || typeof properties !== "object" || Array.isArray(properties)) return [];
+  const required = Array.isArray(schemaRecord.required) ? schemaRecord.required.filter((v) => typeof v === "string") : [];
+  const result = [];
+  for (const [name, rawProp] of Object.entries(properties)) {
+    if (typeof rawProp === "boolean" || !rawProp || typeof rawProp !== "object" || Array.isArray(rawProp)) {
+      continue;
+    }
+    const prop = rawProp;
+    const { type, enumValues } = getFieldType(prop);
+    const fallbackLabel = makeLabel(name);
+    const stepLabel = getXDextoStepLabel(prop) || fallbackLabel;
+    const question = (prop.title ? cleanLabel(prop.title) : "") || fallbackLabel;
+    const helpText = (prop.description ? cleanLabel(prop.description) : "") || void 0;
+    result.push({
+      name,
+      stepLabel,
+      question,
+      helpText,
+      type,
+      required: required.includes(name),
+      enumValues
+    });
+  }
+  return result;
+}
+export {
+  parseElicitationSchema
+};

package/dist/utils/elicitationSchema.test.cjs

@@ -0,0 +1,78 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_elicitationSchema = require("./elicitationSchema.js");
+(0, import_vitest.describe)("parseElicitationSchema", () => {
+  (0, import_vitest.it)("uses a deterministic mapping for question/help/stepLabel", () => {
+    const fields = (0, import_elicitationSchema.parseElicitationSchema)({
+      type: "object",
+      properties: {
+        allow_web_calls: {
+          type: "boolean",
+          title: "If false, I\u2019ll skip live web tools and only test local repo tools.",
+          description: "Allow web calls (web_search / code_search / http_request)",
+          "x-dexto": { stepLabel: "Allow web calls" }
+        },
+        // boolean schema (valid JSON Schema) should be ignored by our UI form renderer
+        ignored: true
+      },
+      required: ["allow_web_calls"]
+    });
+    (0, import_vitest.expect)(fields).toHaveLength(1);
+    (0, import_vitest.expect)(fields[0]).toMatchObject({
+      name: "allow_web_calls",
+      stepLabel: "Allow web calls",
+      question: "If false, I\u2019ll skip live web tools and only test local repo tools.",
+      helpText: "Allow web calls (web_search / code_search / http_request)",
+      type: "boolean",
+      required: true
+    });
+  });
+  (0, import_vitest.it)("falls back to a stable title-cased label when x-dexto.stepLabel is missing", () => {
+    const fields = (0, import_elicitationSchema.parseElicitationSchema)({
+      type: "object",
+      properties: {
+        temp_file_path: {
+          type: "string"
+        }
+      }
+    });
+    (0, import_vitest.expect)(fields).toHaveLength(1);
+    (0, import_vitest.expect)(fields[0]?.stepLabel).toBe("Temp File Path");
+    (0, import_vitest.expect)(fields[0]?.question).toBe("Temp File Path");
+  });
+  (0, import_vitest.it)("detects enum and array-enum field types", () => {
+    const fields = (0, import_elicitationSchema.parseElicitationSchema)({
+      type: "object",
+      properties: {
+        color: {
+          enum: ["red", "green"]
+        },
+        tags: {
+          type: "array",
+          items: { enum: ["a", "b"] }
+        }
+      }
+    });
+    (0, import_vitest.expect)(
+      fields.map((f) => ({ name: f.name, type: f.type, enumValues: f.enumValues }))
+    ).toEqual([
+      { name: "color", type: "enum", enumValues: ["red", "green"] },
+      { name: "tags", type: "array-enum", enumValues: ["a", "b"] }
+    ]);
+  });
+  (0, import_vitest.it)("cleans x-dexto.stepLabel and filters non-string required entries", () => {
+    const fields = (0, import_elicitationSchema.parseElicitationSchema)({
+      type: "object",
+      properties: {
+        allow: {
+          type: "boolean",
+          "x-dexto": { stepLabel: "1) Allow web calls:" }
+        }
+      },
+      required: ["allow", 123]
+    });
+    (0, import_vitest.expect)(fields).toHaveLength(1);
+    (0, import_vitest.expect)(fields[0]?.stepLabel).toBe("Allow web calls");
+    (0, import_vitest.expect)(fields[0]?.required).toBe(true);
+  });
+});

package/dist/utils/elicitationSchema.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=elicitationSchema.test.d.ts.map

package/dist/utils/elicitationSchema.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elicitationSchema.test.d.ts","sourceRoot":"","sources":["../../src/utils/elicitationSchema.test.ts"],"names":[],"mappings":""}

package/dist/utils/elicitationSchema.test.js

@@ -0,0 +1,77 @@
+import { describe, it, expect } from "vitest";
+import { parseElicitationSchema } from "./elicitationSchema.js";
+describe("parseElicitationSchema", () => {
+  it("uses a deterministic mapping for question/help/stepLabel", () => {
+    const fields = parseElicitationSchema({
+      type: "object",
+      properties: {
+        allow_web_calls: {
+          type: "boolean",
+          title: "If false, I\u2019ll skip live web tools and only test local repo tools.",
+          description: "Allow web calls (web_search / code_search / http_request)",
+          "x-dexto": { stepLabel: "Allow web calls" }
+        },
+        // boolean schema (valid JSON Schema) should be ignored by our UI form renderer
+        ignored: true
+      },
+      required: ["allow_web_calls"]
+    });
+    expect(fields).toHaveLength(1);
+    expect(fields[0]).toMatchObject({
+      name: "allow_web_calls",
+      stepLabel: "Allow web calls",
+      question: "If false, I\u2019ll skip live web tools and only test local repo tools.",
+      helpText: "Allow web calls (web_search / code_search / http_request)",
+      type: "boolean",
+      required: true
+    });
+  });
+  it("falls back to a stable title-cased label when x-dexto.stepLabel is missing", () => {
+    const fields = parseElicitationSchema({
+      type: "object",
+      properties: {
+        temp_file_path: {
+          type: "string"
+        }
+      }
+    });
+    expect(fields).toHaveLength(1);
+    expect(fields[0]?.stepLabel).toBe("Temp File Path");
+    expect(fields[0]?.question).toBe("Temp File Path");
+  });
+  it("detects enum and array-enum field types", () => {
+    const fields = parseElicitationSchema({
+      type: "object",
+      properties: {
+        color: {
+          enum: ["red", "green"]
+        },
+        tags: {
+          type: "array",
+          items: { enum: ["a", "b"] }
+        }
+      }
+    });
+    expect(
+      fields.map((f) => ({ name: f.name, type: f.type, enumValues: f.enumValues }))
+    ).toEqual([
+      { name: "color", type: "enum", enumValues: ["red", "green"] },
+      { name: "tags", type: "array-enum", enumValues: ["a", "b"] }
+    ]);
+  });
+  it("cleans x-dexto.stepLabel and filters non-string required entries", () => {
+    const fields = parseElicitationSchema({
+      type: "object",
+      properties: {
+        allow: {
+          type: "boolean",
+          "x-dexto": { stepLabel: "1) Allow web calls:" }
+        }
+      },
+      required: ["allow", 123]
+    });
+    expect(fields).toHaveLength(1);
+    expect(fields[0]?.stepLabel).toBe("Allow web calls");
+    expect(fields[0]?.required).toBe(true);
+  });
+});

package/dist/utils/idGenerator.cjs

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var idGenerator_exports = {};
+__export(idGenerator_exports, {
+  generateMessageId: () => generateMessageId
+});
+module.exports = __toCommonJS(idGenerator_exports);
+var import_crypto = require("crypto");
+function generateMessageId(type) {
+  return `${type}-${(0, import_crypto.randomUUID)()}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateMessageId
+});

package/dist/utils/idGenerator.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Utility for generating unique IDs
+ */
+/**
+ * Generate a unique message ID with a type prefix
+ * @param type - The message type (user, system, error, tool, assistant, command)
+ * @returns A unique ID string
+ */
+export declare function generateMessageId(type: string): string;
+//# sourceMappingURL=idGenerator.d.ts.map

package/dist/utils/idGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"idGenerator.d.ts","sourceRoot":"","sources":["../../src/utils/idGenerator.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtD"}

package/dist/utils/idGenerator.js

@@ -0,0 +1,7 @@
+import { randomUUID } from "crypto";
+function generateMessageId(type) {
+  return `${type}-${randomUUID()}`;
+}
+export {
+  generateMessageId
+};

package/dist/utils/index.cjs

@@ -0,0 +1,62 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  SoundNotificationService: () => import_soundNotification.SoundNotificationService,
+  convertHistoryToUIMessages: () => import_messageFormatting.convertHistoryToUIMessages,
+  createErrorMessage: () => import_messageFormatting.createErrorMessage,
+  createStreamingMessage: () => import_messageFormatting.createStreamingMessage,
+  createSystemMessage: () => import_messageFormatting.createSystemMessage,
+  createToolMessage: () => import_messageFormatting.createToolMessage,
+  createUserMessage: () => import_messageFormatting.createUserMessage,
+  detectAutocompleteType: () => import_inputParsing.detectAutocompleteType,
+  extractResourceQuery: () => import_inputParsing.extractResourceQuery,
+  extractSlashQuery: () => import_inputParsing.extractSlashQuery,
+  findActiveAtIndex: () => import_inputParsing.findActiveAtIndex,
+  generateMessageId: () => import_idGenerator.generateMessageId,
+  getCommandOverlay: () => import_commandOverlays.getCommandOverlay,
+  getStartupInfo: () => import_messageFormatting.getStartupInfo,
+  isInteractiveCommand: () => import_commandOverlays.isInteractiveCommand,
+  playNotificationSound: () => import_soundNotification.playNotificationSound
+});
+module.exports = __toCommonJS(utils_exports);
+var import_inputParsing = require("./inputParsing.js");
+var import_commandOverlays = require("./commandOverlays.js");
+var import_messageFormatting = require("./messageFormatting.js");
+var import_idGenerator = require("./idGenerator.js");
+var import_soundNotification = require("./soundNotification.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SoundNotificationService,
+  convertHistoryToUIMessages,
+  createErrorMessage,
+  createStreamingMessage,
+  createSystemMessage,
+  createToolMessage,
+  createUserMessage,
+  detectAutocompleteType,
+  extractResourceQuery,
+  extractSlashQuery,
+  findActiveAtIndex,
+  generateMessageId,
+  getCommandOverlay,
+  getStartupInfo,
+  isInteractiveCommand,
+  playNotificationSound
+});

package/dist/utils/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Utils module exports
+ */
+export { type AutocompleteType, detectAutocompleteType, extractSlashQuery, extractResourceQuery, findActiveAtIndex, } from './inputParsing.js';
+export { getCommandOverlay, isInteractiveCommand } from './commandOverlays.js';
+export { createUserMessage, createSystemMessage, createErrorMessage, createToolMessage, createStreamingMessage, convertHistoryToUIMessages, getStartupInfo, } from './messageFormatting.js';
+export { generateMessageId } from './idGenerator.js';
+export { playNotificationSound, SoundNotificationService, type SoundType, type SoundConfig, } from './soundNotification.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EACH,KAAK,gBAAgB,EACrB,sBAAsB,EACtB,iBAAiB,EACjB,oBAAoB,EACpB,iBAAiB,GACpB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAG/E,OAAO,EACH,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,sBAAsB,EACtB,0BAA0B,EAC1B,cAAc,GACjB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAGrD,OAAO,EACH,qBAAqB,EACrB,wBAAwB,EACxB,KAAK,SAAS,EACd,KAAK,WAAW,GACnB,MAAM,wBAAwB,CAAC"}