cngkit 1.1.17 → 1.1.19

package/dist/{chunk-HRFI2IEP.js → chunk-7SO75QXJ.js}

@@ -1,10 +1,44 @@
-import {
-  resolveApiBaseUrl
-} from "./chunk-WYJTGGMN.js";
 import {
   __export
 } from "./chunk-PZ5AY32C.js";
 
+// src/shared/config.ts
+import { randomBytes, randomUUID } from "crypto";
+import process2 from "process";
+var packageVersion = "1.1.19";
+var defaultApiBaseUrl = "https://curly.ng";
+function resolveApiBaseUrl(options) {
+  void options;
+  return defaultApiBaseUrl;
+}
+function resolveOutputFormat() {
+  const value = process2.env.CNGKIT_FORMAT?.toLowerCase();
+  if (value === "json" || value === "markdown") {
+    return value;
+  }
+  return "text";
+}
+function parseOutputFormat(value) {
+  const normalizedValue = value.toLowerCase();
+  if (normalizedValue === "text" || normalizedValue === "json" || normalizedValue === "markdown") {
+    return normalizedValue;
+  }
+  throw new Error("Unknown --format value. Use one of: text, json, markdown.");
+}
+function createRoomCode() {
+  return randomBytes(4).toString("hex").toUpperCase();
+}
+function createPeerId() {
+  return randomUUID();
+}
+
+// src/shared/output.ts
+import process3 from "process";
+import { createElement } from "react";
+import { renderToString, Text } from "ink";
+import Markdown from "@inkkit/ink-markdown";
+import stripAnsi from "strip-ansi";
+
 // ../../packages/client/src/generated/core/json.ts
 var toJson = (value, replacer, space) => {
   return JSON.stringify(value, replacer, space);
@@ -298,6 +332,28 @@ var HarnessSemanticSearchResponse;
   };
 })(HarnessSemanticSearchResponse || (HarnessSemanticSearchResponse = {}));
 
+// ../../packages/client/src/generated/api/types/HookifyIngestResponse.ts
+var HookifyIngestResponse;
+((HookifyIngestResponse2) => {
+  HookifyIngestResponse2.Mode = {
+    Sync: "sync",
+    Async: "async"
+  };
+  HookifyIngestResponse2.Status = {
+    Completed: "completed",
+    Pending: "pending"
+  };
+})(HookifyIngestResponse || (HookifyIngestResponse = {}));
+
+// ../../packages/client/src/generated/api/types/HookifyRequestResponse.ts
+var HookifyRequestResponse;
+((HookifyRequestResponse2) => {
+  HookifyRequestResponse2.Status = {
+    Completed: "completed",
+    Pending: "pending"
+  };
+})(HookifyRequestResponse || (HookifyRequestResponse = {}));
+
 // ../../packages/client/src/generated/core/headers.ts
 function mergeHeaders(...headersArray) {
   const result = {};
@@ -1447,6 +1503,174 @@ async function makePassthroughRequest(input, init, clientOptions, requestOptions
   return response;
 }
 
+// ../../packages/client/src/generated/core/file/index.ts
+var file_exports = {};
+__export(file_exports, {
+  toBinaryUploadRequest: () => toBinaryUploadRequest,
+  toMultipartDataPart: () => toMultipartDataPart
+});
+
+// ../../packages/client/src/generated/core/file/file.ts
+async function toBinaryUploadRequest(file) {
+  const { data, filename, contentLength, contentType } = await getFileWithMetadata(file);
+  const request = {
+    body: data,
+    headers: {}
+  };
+  if (filename) {
+    request.headers["Content-Disposition"] = `attachment; filename="${filename}"`;
+  }
+  if (contentType) {
+    request.headers["Content-Type"] = contentType;
+  }
+  if (contentLength != null) {
+    request.headers["Content-Length"] = contentLength.toString();
+  }
+  return request;
+}
+async function toMultipartDataPart(file) {
+  const { data, filename, contentType } = await getFileWithMetadata(file, {
+    noSniffFileSize: true
+  });
+  return {
+    data,
+    filename,
+    contentType
+  };
+}
+async function getFileWithMetadata(file, { noSniffFileSize } = {}) {
+  if (isFileLike(file)) {
+    return getFileWithMetadata(
+      {
+        data: file
+      },
+      { noSniffFileSize }
+    );
+  }
+  if ("path" in file) {
+    const fs = await import("fs");
+    if (!fs?.createReadStream) {
+      throw new Error("File path uploads are not supported in this environment.");
+    }
+    const data = fs.createReadStream(file.path);
+    const contentLength = file.contentLength ?? (noSniffFileSize === true ? void 0 : await tryGetFileSizeFromPath(file.path));
+    const filename = file.filename ?? getNameFromPath(file.path);
+    return {
+      data,
+      filename,
+      contentType: file.contentType,
+      contentLength
+    };
+  }
+  if ("data" in file) {
+    const data = file.data;
+    const contentLength = file.contentLength ?? await tryGetContentLengthFromFileLike(data, {
+      noSniffFileSize
+    });
+    const filename = file.filename ?? tryGetNameFromFileLike(data);
+    return {
+      data,
+      filename,
+      contentType: file.contentType ?? tryGetContentTypeFromFileLike(data),
+      contentLength
+    };
+  }
+  throw new Error(`Invalid FileUpload of type ${typeof file}: ${JSON.stringify(file)}`);
+}
+function isFileLike(value) {
+  return isBuffer(value) || isArrayBufferView(value) || isArrayBuffer(value) || isUint8Array(value) || isBlob(value) || isFile(value) || isStreamLike(value) || isReadableStream(value);
+}
+async function tryGetFileSizeFromPath(path) {
+  try {
+    const fs = await import("fs");
+    if (!fs?.promises?.stat) {
+      return void 0;
+    }
+    const fileStat = await fs.promises.stat(path);
+    return fileStat.size;
+  } catch (_fallbackError) {
+    return void 0;
+  }
+}
+function tryGetNameFromFileLike(data) {
+  if (isNamedValue(data)) {
+    return data.name;
+  }
+  if (isPathedValue(data)) {
+    return getNameFromPath(data.path.toString());
+  }
+  return void 0;
+}
+async function tryGetContentLengthFromFileLike(data, { noSniffFileSize } = {}) {
+  if (isBuffer(data)) {
+    return data.length;
+  }
+  if (isArrayBufferView(data)) {
+    return data.byteLength;
+  }
+  if (isArrayBuffer(data)) {
+    return data.byteLength;
+  }
+  if (isBlob(data)) {
+    return data.size;
+  }
+  if (isFile(data)) {
+    return data.size;
+  }
+  if (noSniffFileSize === true) {
+    return void 0;
+  }
+  if (isPathedValue(data)) {
+    return await tryGetFileSizeFromPath(data.path.toString());
+  }
+  return void 0;
+}
+function tryGetContentTypeFromFileLike(data) {
+  if (isBlob(data)) {
+    return data.type;
+  }
+  if (isFile(data)) {
+    return data.type;
+  }
+  return void 0;
+}
+function getNameFromPath(path) {
+  const lastForwardSlash = path.lastIndexOf("/");
+  const lastBackSlash = path.lastIndexOf("\\");
+  const lastSlashIndex = Math.max(lastForwardSlash, lastBackSlash);
+  return lastSlashIndex >= 0 ? path.substring(lastSlashIndex + 1) : path;
+}
+function isNamedValue(value) {
+  return typeof value === "object" && value != null && "name" in value;
+}
+function isPathedValue(value) {
+  return typeof value === "object" && value != null && "path" in value;
+}
+function isStreamLike(value) {
+  return typeof value === "object" && value != null && ("read" in value || "pipe" in value);
+}
+function isReadableStream(value) {
+  return typeof value === "object" && value != null && "getReader" in value;
+}
+function isBuffer(value) {
+  return typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(value);
+}
+function isArrayBufferView(value) {
+  return typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(value);
+}
+function isArrayBuffer(value) {
+  return typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer;
+}
+function isUint8Array(value) {
+  return typeof Uint8Array !== "undefined" && value instanceof Uint8Array;
+}
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFile(value) {
+  return typeof File !== "undefined" && value instanceof File;
+}
+
 // ../../packages/client/src/generated/core/logging/index.ts
 var logging_exports = {};
 __export(logging_exports, {
@@ -1964,6 +2188,70 @@ var HarnessFilesystemClient = class {
     }
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/harness/filesystem/read");
   }
+  /**
+   * @param {CngApi.GetHarnessFilesystemTailRequest} request
+   * @param {HarnessFilesystemClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link CngApi.BadRequestError}
+   * @throws {@link CngApi.NotFoundError}
+   * @throws {@link CngApi.ContentTooLargeError}
+   *
+   * @example
+   *     await client.harnessFilesystem.getHarnessFilesystemTail({
+   *         file_path: "file_path"
+   *     })
+   */
+  getHarnessFilesystemTail(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getHarnessFilesystemTail(request, requestOptions));
+  }
+  async __getHarnessFilesystemTail(request, requestOptions) {
+    const { file_path: filePath, lines } = request;
+    const _queryParams = {
+      file_path: filePath,
+      lines
+    };
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/filesystem/tail"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 413:
+          throw new ContentTooLargeError(
+            _response.error.body,
+            _response.rawResponse
+          );
+        default:
+          throw new CngApiError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/harness/filesystem/tail");
+  }
   /**
    * @param {CngApi.GetHarnessFilesystemGrepRequest} request
    * @param {HarnessFilesystemClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -2072,6 +2360,226 @@ var HarnessFilesystemClient = class {
     }
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/harness/filesystem/glob");
   }
+  /**
+   * @param {CngApi.GetHarnessFilesystemLsRequest} request
+   * @param {HarnessFilesystemClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link CngApi.BadRequestError}
+   *
+   * @example
+   *     await client.harnessFilesystem.getHarnessFilesystemLs()
+   */
+  getHarnessFilesystemLs(request = {}, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getHarnessFilesystemLs(request, requestOptions));
+  }
+  async __getHarnessFilesystemLs(request = {}, requestOptions) {
+    const { path, limit } = request;
+    const _queryParams = {
+      path,
+      limit
+    };
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/filesystem/ls"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        default:
+          throw new CngApiError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/harness/filesystem/ls");
+  }
+  /**
+   * @param {CngApi.GetHarnessFilesystemTreeRequest} request
+   * @param {HarnessFilesystemClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link CngApi.BadRequestError}
+   *
+   * @example
+   *     await client.harnessFilesystem.getHarnessFilesystemTree()
+   */
+  getHarnessFilesystemTree(request = {}, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getHarnessFilesystemTree(request, requestOptions));
+  }
+  async __getHarnessFilesystemTree(request = {}, requestOptions) {
+    const { path, depth, limit } = request;
+    const _queryParams = {
+      path,
+      depth,
+      limit
+    };
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/filesystem/tree"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        default:
+          throw new CngApiError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/harness/filesystem/tree");
+  }
+  /**
+   * @param {CngApi.GetHarnessFilesystemStatRequest} request
+   * @param {HarnessFilesystemClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link CngApi.BadRequestError}
+   * @throws {@link CngApi.NotFoundError}
+   *
+   * @example
+   *     await client.harnessFilesystem.getHarnessFilesystemStat({
+   *         path: "path"
+   *     })
+   */
+  getHarnessFilesystemStat(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getHarnessFilesystemStat(request, requestOptions));
+  }
+  async __getHarnessFilesystemStat(request, requestOptions) {
+    const { path } = request;
+    const _queryParams = {
+      path
+    };
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/filesystem/stat"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        default:
+          throw new CngApiError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/harness/filesystem/stat");
+  }
+  /**
+   * @param {CngApi.GetHarnessFilesystemFindRequest} request
+   * @param {HarnessFilesystemClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link CngApi.BadRequestError}
+   *
+   * @example
+   *     await client.harnessFilesystem.getHarnessFilesystemFind()
+   */
+  getHarnessFilesystemFind(request = {}, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getHarnessFilesystemFind(request, requestOptions));
+  }
+  async __getHarnessFilesystemFind(request = {}, requestOptions) {
+    const { path, name, type: type_, max_depth: maxDepth, limit } = request;
+    const _queryParams = {
+      path,
+      name,
+      type: type_ != null ? type_ : void 0,
+      max_depth: maxDepth,
+      limit
+    };
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/harness/filesystem/find"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: _response.body,
+        rawResponse: _response.rawResponse
+      };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        default:
+          throw new CngApiError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/harness/filesystem/find");
+  }
 };
 
 // ../../packages/client/src/generated/api/resources/harnessInternalKnowledges/client/Client.ts
@@ -2087,12 +2595,12 @@ var HarnessInternalKnowledgesClient = class {
    * @throws {@link CngApi.ServiceUnavailableError}
    *
    * @example
-   *     await client.harnessInternalKnowledges.createHarnessSubskillAssetsSyncPlan()
+   *     await client.harnessInternalKnowledges.createHarnessTopicAssetsSyncPlan()
    */
-  createHarnessSubskillAssetsSyncPlan(requestOptions) {
-    return HttpResponsePromise.fromPromise(this.__createHarnessSubskillAssetsSyncPlan(requestOptions));
+  createHarnessTopicAssetsSyncPlan(requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__createHarnessTopicAssetsSyncPlan(requestOptions));
   }
-  async __createHarnessSubskillAssetsSyncPlan(requestOptions) {
+  async __createHarnessTopicAssetsSyncPlan(requestOptions) {
     const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
     const _response = await fetcher({
       url: url_exports.join(
@@ -2134,7 +2642,7 @@ var HarnessInternalKnowledgesClient = class {
     );
   }
   /**
-   * @param {CngApi.GetHarnessSubskillAssetRawFileRequest} request
+   * @param {CngApi.GetHarnessTopicAssetRawFileRequest} request
    * @param {HarnessInternalKnowledgesClient.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @throws {@link CngApi.UnauthorizedError}
@@ -2142,15 +2650,15 @@ var HarnessInternalKnowledgesClient = class {
    * @throws {@link CngApi.ServiceUnavailableError}
    *
    * @example
-   *     await client.harnessInternalKnowledges.getHarnessSubskillAssetRawFile({
+   *     await client.harnessInternalKnowledges.getHarnessTopicAssetRawFile({
    *         path: "x",
    *         sha256: "sha256"
    *     })
    */
-  getHarnessSubskillAssetRawFile(request, requestOptions) {
-    return HttpResponsePromise.fromPromise(this.__getHarnessSubskillAssetRawFile(request, requestOptions));
+  getHarnessTopicAssetRawFile(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getHarnessTopicAssetRawFile(request, requestOptions));
   }
-  async __getHarnessSubskillAssetRawFile(request, requestOptions) {
+  async __getHarnessTopicAssetRawFile(request, requestOptions) {
     const { path, sha256 } = request;
     const _queryParams = {
       path,
@@ -2204,12 +2712,12 @@ var HarnessInternalKnowledgesClient = class {
    * @throws {@link CngApi.UnauthorizedError}
    *
    * @example
-   *     await client.harnessInternalKnowledges.listHarnessSubskillAssetHashes()
+   *     await client.harnessInternalKnowledges.listHarnessTopicAssetHashes()
    */
-  listHarnessSubskillAssetHashes(requestOptions) {
-    return HttpResponsePromise.fromPromise(this.__listHarnessSubskillAssetHashes(requestOptions));
+  listHarnessTopicAssetHashes(requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__listHarnessTopicAssetHashes(requestOptions));
   }
-  async __listHarnessSubskillAssetHashes(requestOptions) {
+  async __listHarnessTopicAssetHashes(requestOptions) {
     const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
     const _response = await fetcher({
       url: url_exports.join(
@@ -2258,26 +2766,29 @@ var HarnessInternalKnowledgesClient = class {
    * @throws {@link CngApi.ConflictError}
    *
    * @example
-   *     await client.harnessInternalKnowledges.replaceHarnessSubskillAssets({
+   *     await client.harnessInternalKnowledges.replaceHarnessTopicAssets({
    *         uploadedAt: "uploadedAt",
    *         files: [{
    *                 path: "path",
+   *                 slug: "slug",
    *                 sha256: "sha256",
    *                 size: 1,
    *                 mode: "mode",
    *                 assetKind: "skill",
-   *                 subskillName: "subskillName",
+   *                 topicName: "topicName",
    *                 displayTitle: "displayTitle",
    *                 displayDescription: "displayDescription",
    *                 displayRating: 1,
+   *                 sourceText: "sourceText",
+   *                 frontmatterText: "frontmatterText",
    *                 bodyText: "bodyText"
    *             }]
    *     })
    */
-  replaceHarnessSubskillAssets(request, requestOptions) {
-    return HttpResponsePromise.fromPromise(this.__replaceHarnessSubskillAssets(request, requestOptions));
+  replaceHarnessTopicAssets(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__replaceHarnessTopicAssets(request, requestOptions));
   }
-  async __replaceHarnessSubskillAssets(request, requestOptions) {
+  async __replaceHarnessTopicAssets(request, requestOptions) {
     const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
     const _response = await fetcher({
       url: url_exports.join(
@@ -2331,15 +2842,15 @@ var HarnessInternalKnowledgesClient = class {
    * @throws {@link CngApi.ConflictError}
    *
    * @example
-   *     await client.harnessInternalKnowledges.deleteHarnessSubskillAssets({
+   *     await client.harnessInternalKnowledges.deleteHarnessTopicAssets({
    *         uploadedAt: "uploadedAt",
    *         paths: ["paths"]
    *     })
    */
-  deleteHarnessSubskillAssets(request, requestOptions) {
-    return HttpResponsePromise.fromPromise(this.__deleteHarnessSubskillAssets(request, requestOptions));
+  deleteHarnessTopicAssets(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__deleteHarnessTopicAssets(request, requestOptions));
   }
-  async __deleteHarnessSubskillAssets(request, requestOptions) {
+  async __deleteHarnessTopicAssets(request, requestOptions) {
     const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
     const _response = await fetcher({
       url: url_exports.join(
@@ -2389,23 +2900,23 @@ var HarnessInternalKnowledgesClient = class {
     );
   }
   /**
-   * @param {CngApi.HarnessUploadSubskillAssetsIndexRequest} request
+   * @param {CngApi.HarnessUploadTopicAssetsIndexRequest} request
    * @param {HarnessInternalKnowledgesClient.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @throws {@link CngApi.UnauthorizedError}
    * @throws {@link CngApi.InternalServerError}
    *
    * @example
-   *     await client.harnessInternalKnowledges.createHarnessSubskillAssetsIndex({
+   *     await client.harnessInternalKnowledges.createHarnessTopicAssetsIndex({
    *         runId: "runId",
    *         offset: 1,
    *         limit: 1
    *     })
    */
-  createHarnessSubskillAssetsIndex(request, requestOptions) {
-    return HttpResponsePromise.fromPromise(this.__createHarnessSubskillAssetsIndex(request, requestOptions));
+  createHarnessTopicAssetsIndex(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__createHarnessTopicAssetsIndex(request, requestOptions));
   }
-  async __createHarnessSubskillAssetsIndex(request, requestOptions) {
+  async __createHarnessTopicAssetsIndex(request, requestOptions) {
     const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
     const _response = await fetcher({
       url: url_exports.join(
@@ -2550,16 +3061,16 @@ var HarnessKnowledgesClient = class {
     );
   }
   /**
-   * @param {CngApi.ListHarnessSubskillAssetsRequest} request
+   * @param {CngApi.ListHarnessTopicAssetsRequest} request
    * @param {HarnessKnowledgesClient.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @example
-   *     await client.harnessKnowledges.listHarnessSubskillAssets()
+   *     await client.harnessKnowledges.listHarnessTopicAssets()
    */
-  listHarnessSubskillAssets(request = {}, requestOptions) {
-    return HttpResponsePromise.fromPromise(this.__listHarnessSubskillAssets(request, requestOptions));
+  listHarnessTopicAssets(request = {}, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__listHarnessTopicAssets(request, requestOptions));
   }
-  async __listHarnessSubskillAssets(request = {}, requestOptions) {
+  async __listHarnessTopicAssets(request = {}, requestOptions) {
     const { q, audience, limit } = request;
     const _queryParams = {
       q,
@@ -2582,10 +3093,7 @@ var HarnessKnowledgesClient = class {
       logging: this._options.logging
     });
     if (_response.ok) {
-      return {
-        data: _response.body,
-        rawResponse: _response.rawResponse
-      };
+      return { data: _response.body, rawResponse: _response.rawResponse };
     }
     if (_response.error.reason === "status-code") {
       throw new CngApiError({
@@ -2739,22 +3247,22 @@ var HarnessKnowledgesClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/harness/knowledges/brain");
   }
   /**
-   * Returns the full subskill index for agent discovery. Use search for semantic lookup, or filesystem/read for content.
+   * Returns the full topic index for agent discovery. Use search for semantic lookup, or filesystem/read for content.
    *
    * @param {HarnessKnowledgesClient.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @example
-   *     await client.harnessKnowledges.listHarnessKnowledgesSubskills()
+   *     await client.harnessKnowledges.listHarnessKnowledgesTopics()
    */
-  listHarnessKnowledgesSubskills(requestOptions) {
-    return HttpResponsePromise.fromPromise(this.__listHarnessKnowledgesSubskills(requestOptions));
+  listHarnessKnowledgesTopics(requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__listHarnessKnowledgesTopics(requestOptions));
   }
-  async __listHarnessKnowledgesSubskills(requestOptions) {
+  async __listHarnessKnowledgesTopics(requestOptions) {
     const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
     const _response = await fetcher({
       url: url_exports.join(
         await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
-        "api/harness/knowledges/subskills"
+        "api/harness/knowledges/topics"
       ),
       method: "GET",
       headers: _headers,
@@ -2779,7 +3287,7 @@ var HarnessKnowledgesClient = class {
       _response.error,
       _response.rawResponse,
       "GET",
-      "/api/harness/knowledges/subskills"
+      "/api/harness/knowledges/topics"
     );
   }
   /**
@@ -2870,6 +3378,109 @@ var HarnessKnowledgesClient = class {
   }
 };
 
+// ../../packages/client/src/generated/api/resources/hookify/client/Client.ts
+var HookifyClient = class {
+  _options;
+  constructor(options = {}) {
+    this._options = normalizeClientOptions(options);
+  }
+  /**
+   * @param {core.file.Uploadable} uploadable
+   * @param {CngApi.IngestHookifyHookRequest} request
+   * @param {HookifyClient.RequestOptions} requestOptions - Request-specific configuration.
+   */
+  ingestHookifyHook(uploadable, request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__ingestHookifyHook(uploadable, request, requestOptions));
+  }
+  async __ingestHookifyHook(uploadable, request, requestOptions) {
+    const _queryParams = {
+      mode: request.mode != null ? request.mode : void 0,
+      event: request.event
+    };
+    const _binaryUploadRequest = await file_exports.toBinaryUploadRequest(uploadable);
+    const _headers = mergeHeaders(
+      this._options?.headers,
+      _binaryUploadRequest.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        "api/hookify/ingest"
+      ),
+      method: "POST",
+      headers: _headers,
+      contentType: "application/octet-stream",
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "bytes",
+      duplex: "half",
+      body: _binaryUploadRequest.body,
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      throw new CngApiError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body,
+        rawResponse: _response.rawResponse
+      });
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/api/hookify/ingest");
+  }
+  /**
+   * @param {CngApi.GetHookifyRequestRequest} request
+   * @param {HookifyClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.hookify.getHookifyRequest({
+   *         requestId: "requestId"
+   *     })
+   */
+  getHookifyRequest(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getHookifyRequest(request, requestOptions));
+  }
+  async __getHookifyRequest(request, requestOptions) {
+    const { requestId } = request;
+    const _headers = mergeHeaders(this._options?.headers, requestOptions?.headers);
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment) ?? CngApiEnvironment.Default,
+        `api/hookify/requests/${url_exports.encodePathParam(requestId)}`
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      throw new CngApiError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body,
+        rawResponse: _response.rawResponse
+      });
+    }
+    return handleNonStatusCodeError(
+      _response.error,
+      _response.rawResponse,
+      "GET",
+      "/api/hookify/requests/{requestId}"
+    );
+  }
+};
+
 // ../../packages/client/src/generated/api/resources/llm/client/Client.ts
 var LlmClient = class {
   _options;
@@ -3142,6 +3753,7 @@ var CngApiClient = class {
   _polar;
   _telemetry;
   _llm;
+  _hookify;
   constructor(options = {}) {
     this._options = normalizeClientOptions(options);
   }
@@ -3169,6 +3781,9 @@ var CngApiClient = class {
   get llm() {
     return this._llm ??= new LlmClient(this._options);
   }
+  get hookify() {
+    return this._hookify ??= new HookifyClient(this._options);
+  }
   /**
    * Make a passthrough request using the SDK's configured auth, retry, logging, etc.
    * This is useful for making requests to endpoints not yet supported in the SDK.
@@ -3203,32 +3818,235 @@ var logging;
   logging2.ConsoleLogger = ConsoleLogger;
 })(logging || (logging = {}));
 
-// src/shared/api-client.ts
-function createCngApiClient(options) {
-  return new CngApiClient({
-    baseUrl: resolveApiBaseUrl(options),
-    timeoutInSeconds: 15,
-    maxRetries: 1
+// src/shared/theme.ts
+import { Chalk } from "chalk";
+var statusStylePropsByOutputStyle = {
+  info: {
+    color: "cyan"
+  },
+  success: {
+    color: "green",
+    bold: true
+  },
+  warning: {
+    color: "yellow",
+    bold: true
+  },
+  muted: {
+    dimColor: true
+  },
+  error: {
+    color: "red",
+    bold: true
+  }
+};
+function createMarkdownTheme(useColor) {
+  const chalk = new Chalk({ level: useColor ? 1 : 0 });
+  const identity = (value) => value;
+  return {
+    code: chalk.green,
+    blockquote: chalk.dim.italic,
+    html: chalk.gray,
+    heading: chalk.blueBright.bold,
+    firstHeading: chalk.magentaBright.bold,
+    hr: chalk.gray,
+    listitem: identity,
+    table: identity,
+    paragraph: identity,
+    strong: chalk.bold,
+    em: chalk.italic,
+    codespan: chalk.cyanBright,
+    del: chalk.dim.strikethrough,
+    link: chalk.blueBright,
+    href: chalk.blue.underline,
+    text: identity,
+    showSectionPrefix: false,
+    reflowText: true,
+    unescape: true,
+    emoji: false,
+    tab: 2
+  };
+}
+
+// src/shared/output.ts
+var consoleOutput = createCommandOutput(process3.stdout, process3.stderr);
+function createCommandOutput(stdout, stderr) {
+  return {
+    info(message) {
+      writeStyledMessage(stdout, "info", message);
+    },
+    success(message) {
+      writeStyledMessage(stdout, "success", message);
+    },
+    warning(message) {
+      writeStyledMessage(stdout, "warning", message);
+    },
+    muted(message) {
+      writeStyledMessage(stdout, "muted", message);
+    },
+    markdown(message) {
+      stdout.write(`${formatMarkdownMessage(stdout, message)}
+`);
+    },
+    component(element) {
+      stdout.write(`${formatComponentMessage(stdout, element)}
+`);
+    },
+    raw(message) {
+      stdout.write(`${message}
+`);
+    },
+    error(message) {
+      writeStyledMessage(stderr, "error", message);
+    }
+  };
+}
+function formatError(error) {
+  if (error instanceof CngApiError) {
+    return formatApiError(error);
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+function formatApiError(error) {
+  if (resolveOutputFormat() === "json") {
+    return error.message;
+  }
+  const statusCode = error.statusCode ?? 0;
+  if (statusCode >= 500) {
+    return `Backend error (${statusCode}). The service encountered an internal error.`;
+  }
+  if (statusCode >= 400) {
+    const bodyMessage = extractBodyErrorMessage(error.body);
+    if (bodyMessage) {
+      return `Request error (${statusCode}): ${bodyMessage}`;
+    }
+    return `Request error (${statusCode}).`;
+  }
+  return error.message;
+}
+function extractBodyErrorMessage(body) {
+  if (body == null || typeof body !== "object") {
+    return void 0;
+  }
+  const record = body;
+  const errorField = record.error;
+  if (errorField != null && typeof errorField === "object") {
+    const message = errorField.message;
+    if (typeof message === "string") {
+      return message;
+    }
+  }
+  if (typeof record.message === "string") {
+    return record.message;
+  }
+  return void 0;
+}
+function writeStyledMessage(stream, style, message) {
+  stream.write(`${formatStyledMessage(stream, style, message)}
+`);
+}
+function formatStyledMessage(stream, style, message) {
+  if (!shouldRenderColor(stream)) {
+    return message;
+  }
+  return renderToString(
+    createElement(
+      Text,
+      {
+        ...statusStylePropsByOutputStyle[style],
+        wrap: "wrap"
+      },
+      message
+    ),
+    {
+      columns: 1e4
+    }
+  );
+}
+function formatMarkdownMessage(stream, markdown) {
+  if (resolveOutputFormat() === "markdown") {
+    return markdown;
+  }
+  const useColor = shouldRenderColor(stream);
+  const markdownWidth = clampMarkdownWidth(stream.columns);
+  const preparedMarkdown = prepareMarkdownForTerminal(markdown);
+  const renderedMarkdown = renderToString(
+    createElement(Markdown, {
+      ...createMarkdownTheme(useColor),
+      children: preparedMarkdown,
+      width: markdownWidth
+    }),
+    {
+      columns: markdownWidth
+    }
+  );
+  return useColor ? renderedMarkdown.trimEnd() : stripAnsi(renderedMarkdown).trimEnd();
+}
+function formatComponentMessage(stream, element) {
+  const useColor = shouldRenderColor(stream);
+  const renderWidth = clampMarkdownWidth(stream.columns);
+  const rendered = renderToString(element, {
+    columns: renderWidth
   });
+  return useColor ? rendered.trimEnd() : stripAnsi(rendered).trimEnd();
 }
-async function readBackendHealth(options) {
-  try {
-    const client = createCngApiClient(options);
-    const health = await client.system.getHealth();
-    return {
-      ok: true,
-      service: health.service
-    };
-  } catch (error) {
-    return {
-      ok: false,
-      message: error instanceof Error ? error.message : "unknown error"
-    };
+function prepareMarkdownForTerminal(markdown) {
+  if (!markdown.startsWith("---\n")) {
+    return markdown;
+  }
+  const frontmatterEndIndex = markdown.indexOf("\n---", 4);
+  if (frontmatterEndIndex < 0) {
+    return formatFrontmatterForTerminal(markdown.slice(4).trimEnd());
+  }
+  const frontmatter = markdown.slice(4, frontmatterEndIndex).trimEnd();
+  const body = markdown.slice(frontmatterEndIndex + "\n---".length).replace(/^\n+/, "");
+  return `${formatFrontmatterForTerminal(frontmatter)}
+
+${body}`;
+}
+function formatFrontmatterForTerminal(frontmatter) {
+  return `## Metadata
+
+\`\`\`yaml
+${frontmatter}
+\`\`\``;
+}
+function shouldRenderColor(stream) {
+  if (process3.env.CNGKIT_NO_COLOR === "1") {
+    return false;
+  }
+  const colorMode = process3.env.CNGKIT_COLOR?.toLowerCase();
+  if (colorMode === "never" || colorMode === "0" || colorMode === "false") {
+    return false;
+  }
+  if (colorMode === "always" || colorMode === "1" || colorMode === "true") {
+    return true;
+  }
+  if (process3.env.FORCE_COLOR !== void 0 && process3.env.FORCE_COLOR !== "0") {
+    return true;
+  }
+  if (process3.env.NO_COLOR !== void 0) {
+    return false;
+  }
+  return stream.isTTY === true;
+}
+function clampMarkdownWidth(columns) {
+  if (columns === void 0) {
+    return 100;
   }
+  return Math.max(72, Math.min(columns, 120));
 }
 
 export {
-  createCngApiClient,
-  readBackendHealth
+  CngApiClient,
+  packageVersion,
+  resolveApiBaseUrl,
+  resolveOutputFormat,
+  parseOutputFormat,
+  createRoomCode,
+  createPeerId,
+  consoleOutput,
+  createCommandOutput,
+  formatError
 };
-//# sourceMappingURL=chunk-HRFI2IEP.js.map
+//# sourceMappingURL=chunk-7SO75QXJ.js.map