cngkit 1.1.18 → 1.1.20

package/dist/chunk-NODJM6SH.js

@@ -0,0 +1,658 @@
+import {
+  coerceLimit,
+  coerceOptionalNumber,
+  formatJson,
+  shouldPrintJson,
+  singleLine
+} from "./chunk-XQGLUQFM.js";
+import {
+  createCngApiClient
+} from "./chunk-CIZBVLN5.js";
+import {
+  resolveOutputFormat
+} from "./chunk-WDI43VPW.js";
+
+// src/features/knowledges/run-knowledges-command.ts
+import { createElement } from "react";
+
+// src/features/knowledges/knowledges-api.ts
+function createKnowledgesApi(options) {
+  const client = createCngApiClient(options);
+  return {
+    getCatalog: () => client.harnessKnowledges.getHarnessKnowledgesCatalog(),
+    listAudiences: () => client.harnessKnowledges.listHarnessKnowledgesAudiences(),
+    search: (query, limit) => client.harnessKnowledges.searchHarnessKnowledges({
+      q: query,
+      limit
+    }),
+    listTopics: () => client.harnessKnowledges.listHarnessKnowledgesTopics(),
+    listFiles: ({ query, audience, limit }) => client.harnessKnowledges.listHarnessTopicAssets({
+      ...query ? { q: query } : {},
+      ...audience ? { audience } : {},
+      limit
+    }),
+    read: ({ filePath, offset, limit }) => client.harnessFilesystem.getHarnessFilesystemRead({
+      file_path: filePath,
+      offset,
+      limit
+    }),
+    grep: ({ pattern, path, include, mode, context, ignoreCase }) => client.harnessFilesystem.getHarnessFilesystemGrep({
+      pattern,
+      path,
+      include,
+      output_mode: mode,
+      context,
+      case_insensitive: ignoreCase ? "true" : void 0
+    }),
+    glob: ({ pattern, path }) => client.harnessFilesystem.getHarnessFilesystemGlob({
+      pattern,
+      path
+    }),
+    listDirectory: ({ path, limit }) => client.harnessFilesystem.getHarnessFilesystemLs({
+      path,
+      limit
+    }),
+    tree: ({ path, depth, limit }) => client.harnessFilesystem.getHarnessFilesystemTree({
+      path,
+      depth,
+      limit
+    }),
+    find: ({ path, name, type, maxDepth, limit }) => client.harnessFilesystem.getHarnessFilesystemFind({
+      path,
+      ...name ? { name } : {},
+      ...type ? { type } : {},
+      ...maxDepth !== void 0 ? { max_depth: maxDepth } : {},
+      limit
+    }),
+    tail: ({ filePath, lines }) => client.harnessFilesystem.getHarnessFilesystemTail({
+      file_path: filePath,
+      lines
+    }),
+    statPath: ({ path }) => client.harnessFilesystem.getHarnessFilesystemStat({
+      path
+    })
+  };
+}
+
+// src/features/knowledges/knowledges-input.ts
+var storedTopicsRoot = "skills/knowledges/topics";
+function normalizeAudienceId(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  switch (value) {
+    case "all":
+    case "operators":
+    case "builders":
+    case "researchers":
+    case "agent-makers":
+      return value;
+    default:
+      throw new Error(
+        `Unknown audience "${value}". Run cngkit knowledges audiences to see supported values.`
+      );
+  }
+}
+function normalizeCatalogPath(value) {
+  const trimmed = value.trim();
+  if (trimmed === "/" || trimmed === "") {
+    return storedTopicsRoot;
+  }
+  const relativePath = trimmed.replace(/^\/+/, "");
+  if (relativePath === storedTopicsRoot || relativePath.startsWith(`${storedTopicsRoot}/`)) {
+    return relativePath;
+  }
+  const topicRelativePath = relativePath.startsWith("topics/") ? relativePath.slice("topics/".length) : relativePath;
+  const [firstSegment, ...restSegments] = relativePath.split("/");
+  if (!firstSegment) {
+    return relativePath;
+  }
+  switch (firstSegment) {
+    case "concepts":
+    case "domains":
+    case "formats":
+    case "languages":
+    case "libraries":
+    case "patterns":
+    case "platforms":
+    case "procedures":
+    case "protocols":
+    case "tools":
+      return `${storedTopicsRoot}/${firstSegment}${restSegments.length > 0 ? `/${restSegments.join("/")}` : ""}`;
+    default:
+      return `${storedTopicsRoot}/${topicRelativePath}`;
+  }
+}
+function normalizeFilesystemCatalogPath(value) {
+  const trimmed = value.trim();
+  if (trimmed === "/" || trimmed === "") {
+    return storedTopicsRoot;
+  }
+  return normalizeCatalogPath(trimmed);
+}
+function formatCatalogPathForDisplay(value) {
+  const normalized = value.replace(/\/+$/, "");
+  if (normalized === storedTopicsRoot) {
+    return "/";
+  }
+  if (normalized.startsWith(`${storedTopicsRoot}/`)) {
+    return `/${normalized.slice(storedTopicsRoot.length + 1)}`;
+  }
+  return value;
+}
+function normalizeGrepMode(value) {
+  if (value === void 0) {
+    return "content";
+  }
+  switch (value) {
+    case "content":
+    case "files_with_matches":
+    case "count":
+      return value;
+    default:
+      throw new Error("Unknown grep mode. Use one of: content, files_with_matches, count.");
+  }
+}
+
+// src/features/knowledges/knowledges-output.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function KnowCatalogSummary({ catalog }) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, children: "Catalog: " }),
+      catalog.name
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, children: "Files: " }),
+      catalog.files
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, children: "Blobs: " }),
+      catalog.blobs
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, children: "Database: " }),
+      catalog.database.engine,
+      " (",
+      catalog.database.binding,
+      ")"
+    ] })
+  ] });
+}
+function KnowAudienceList({ audiences }) {
+  if (audiences.length === 0) {
+    return /* @__PURE__ */ jsx(Text, { color: "yellow", children: "No audiences available." });
+  }
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: audiences.map((audience) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { color: "cyan", children: audience.id }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        " - ",
+        audience.label
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: singleLine(audience.help) })
+  ] }, audience.id)) });
+}
+function KnowSearchResults({
+  results
+}) {
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: results.map((result, index) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+        index + 1,
+        ". "
+      ] }),
+      /* @__PURE__ */ jsx(Text, { bold: true, children: result.title }),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        " (",
+        result.topicName,
+        ")"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      "score ",
+      result.score.toFixed(3),
+      " | ",
+      formatCatalogPathForDisplay(result.path)
+    ] }),
+    /* @__PURE__ */ jsx(Text, { children: singleLine(result.description || result.contentPreview) })
+  ] }, result.id)) });
+}
+function KnowTopicList({ topics }) {
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: topics.map((topic) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { color: "cyan", children: topic.name }),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        " [",
+        topic.type,
+        "]"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      topic.title,
+      " | files ",
+      topic.fileCount,
+      " | rating ",
+      topic.rating
+    ] }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: singleLine(topic.description) })
+  ] }, topic.id)) });
+}
+function KnowTopicFileList({ files }) {
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: files.map((file) => {
+    const title = file.display_title ?? file.title ?? file.topic_name ?? "Untitled";
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx(Text, { color: "cyan", children: formatCatalogPathForDisplay(file.path) }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: title })
+    ] }, `${file.path}-${file.sha256}`);
+  }) });
+}
+
+// src/features/knowledges/run-knowledges-command.ts
+async function runKnowStatusCommand(options, output, dependencies) {
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const response = await api.getCatalog();
+  if (shouldPrintJson(options)) {
+    output.raw(formatJson(response.data));
+    return;
+  }
+  output.component(createElement(KnowCatalogSummary, { catalog: response.data }));
+}
+async function runKnowAudiencesCommand(options, output, dependencies) {
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const response = await api.listAudiences();
+  if (shouldPrintJson(options)) {
+    output.raw(formatJson(response.data));
+    return;
+  }
+  output.component(createElement(KnowAudienceList, { audiences: response.data.audiences }));
+}
+async function runKnowSearchCommand(query, options, output, dependencies) {
+  if (!query) {
+    throw new Error("Missing search query. Usage: cngkit knowledges search <query>");
+  }
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const response = await api.search(query, coerceLimit(options.limit, 5));
+  if (shouldPrintJson(options)) {
+    output.raw(formatJson(response.data));
+    return;
+  }
+  if (response.data.results.length > 0) {
+    output.component(createElement(KnowSearchResults, { results: response.data.results }));
+    return;
+  }
+  output.warning(`No results for "${query}".`);
+}
+async function runKnowListCommand(query, options, output, dependencies) {
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const response = await api.listTopics();
+  const limit = coerceLimit(options.limit, 25);
+  const normalizedQuery = query?.toLowerCase();
+  const topics = response.data.topics.filter((topic) => {
+    if (!normalizedQuery) {
+      return true;
+    }
+    return [topic.name, topic.title, topic.description, topic.type].join(" ").toLowerCase().includes(normalizedQuery);
+  }).slice(0, limit);
+  if (shouldPrintJson(options)) {
+    output.raw(formatJson({ topics, total: topics.length }));
+    return;
+  }
+  if (topics.length > 0) {
+    output.component(createElement(KnowTopicList, { topics }));
+    return;
+  }
+  output.warning("No matching topics.");
+}
+async function runKnowFilesCommand(query, options, output, dependencies) {
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const response = await api.listFiles({
+    query,
+    audience: normalizeAudienceId(options.audience),
+    limit: coerceLimit(options.limit, 25)
+  });
+  if (shouldPrintJson(options)) {
+    output.raw(formatJson(response.data));
+    return;
+  }
+  if (response.data.files.length > 0) {
+    output.component(createElement(KnowTopicFileList, { files: response.data.files }));
+    return;
+  }
+  output.warning("No matching files.");
+}
+async function runKnowReadCommand(filePath, options, output, dependencies) {
+  if (!filePath) {
+    throw new Error("Missing file_path. Usage: cngkit knowledges read <file_path>");
+  }
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const response = await api.read({
+    filePath: normalizeCatalogPath(filePath),
+    offset: coerceOptionalNumber(options.offset),
+    limit: coerceLimit(options.limit, 200, 2e3)
+  });
+  if (shouldPrintJson(options)) {
+    output.raw(formatJson(response.data));
+    return;
+  }
+  if (resolveOutputFormat() === "markdown" || !response.data.file_path.endsWith(".md")) {
+    output.raw(response.data.content);
+  } else {
+    output.markdown(response.data.content);
+  }
+  if (response.data.truncated) {
+    output.warning(
+      `[truncated: showing ${response.data.limit} lines from offset ${response.data.offset} of ${response.data.total_lines}]`
+    );
+  }
+}
+async function runKnowCatCommand(filePath, options, output, dependencies) {
+  if (!filePath) {
+    throw new Error("Missing file_path. Usage: cngkit knowledges cat <file_path>");
+  }
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const response = await api.read({
+    filePath: normalizeCatalogPath(filePath),
+    offset: 0,
+    limit: 2e3
+  });
+  outputRawContent(response.data, options, output);
+}
+async function runKnowHeadCommand(filePath, options, output, dependencies) {
+  if (!filePath) {
+    throw new Error("Missing file_path. Usage: cngkit knowledges head <file_path> -n 10");
+  }
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const response = await api.read({
+    filePath: normalizeCatalogPath(filePath),
+    offset: 0,
+    limit: coerceLimit(options.lines, 10, 2e3)
+  });
+  outputRawContent(response.data, options, output);
+}
+async function runKnowTailCommand(filePath, options, output, dependencies) {
+  if (!filePath) {
+    throw new Error("Missing file_path. Usage: cngkit knowledges tail <file_path> -n 10");
+  }
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const response = await api.tail({
+    filePath: normalizeCatalogPath(filePath),
+    lines: coerceLimit(options.lines, 10, 2e3)
+  });
+  outputRawContent(response.data, options, output);
+}
+async function runKnowGrepCommand(pattern, options, output, dependencies) {
+  if (!pattern) {
+    throw new Error("Missing pattern. Usage: cngkit knowledges grep <pattern>");
+  }
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const limit = options.limit !== void 0 ? coerceOptionalNumber(options.limit) : void 0;
+  const response = await api.grep({
+    pattern,
+    path: normalizeCatalogPath(options.path ?? "/"),
+    include: options.include ?? "*",
+    mode: normalizeGrepMode(options.outputMode),
+    context: coerceLimit(options.context, 0, 20),
+    ignoreCase: options.caseInsensitive === true
+  });
+  if (shouldPrintJson(options)) {
+    output.raw(formatJson(response.data));
+    return;
+  }
+  if (response.data.mode === "files_with_matches") {
+    const files = limit ? response.data.files.slice(0, limit) : response.data.files;
+    if (files.length > 0) {
+      output.raw(files.map(formatCatalogPathForDisplay).join("\n"));
+      return;
+    }
+    output.warning(`No files matched "${pattern}".`);
+    return;
+  }
+  if (response.data.mode === "count") {
+    const counts = limit ? response.data.counts.slice(0, limit) : response.data.counts;
+    const lines2 = counts.map(
+      (count) => `${formatCatalogPathForDisplay(count.file_path)}: ${count.match_count}`
+    );
+    if (lines2.length > 0) {
+      output.raw(lines2.join("\n"));
+      return;
+    }
+    output.warning(`No matches for "${pattern}".`);
+    return;
+  }
+  const matches = limit ? response.data.matches.slice(0, limit) : response.data.matches;
+  const lines = matches.flatMap((match) => [
+    `${formatCatalogPathForDisplay(match.file_path)}:${match.line_number}`,
+    ...match.context_before.map((line) => `  ${line}`),
+    `> ${match.line}`,
+    ...match.context_after.map((line) => `  ${line}`)
+  ]);
+  if (lines.length > 0) {
+    output.raw(lines.join("\n"));
+    return;
+  }
+  output.warning(`No matches for "${pattern}".`);
+}
+async function runKnowGlobCommand(pattern, options, output, dependencies) {
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const limit = options.limit !== void 0 ? coerceOptionalNumber(options.limit) : void 0;
+  const response = await api.glob({
+    pattern: pattern ?? "**/*.md",
+    path: normalizeCatalogPath(options.path ?? "/")
+  });
+  if (shouldPrintJson(options)) {
+    output.raw(formatJson(response.data));
+    return;
+  }
+  const files = limit ? response.data.files.slice(0, limit) : response.data.files;
+  const wasClientTruncated = limit ? response.data.files.length > limit : false;
+  if (files.length > 0) {
+    output.raw(files.map(formatCatalogPathForDisplay).join("\n"));
+  } else {
+    output.warning("No matching files.");
+  }
+  if (response.data.truncated || wasClientTruncated) {
+    output.warning(`[truncated: ${response.data.total_files} total files]`);
+  }
+}
+async function runKnowLsCommand(path, options, output, dependencies) {
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const response = await api.listDirectory({
+    path: normalizeFilesystemCatalogPath(path ?? "/"),
+    limit: coerceLimit(options.limit, 100, 1e3)
+  });
+  if (shouldPrintJson(options)) {
+    output.raw(formatJson(response.data));
+    return;
+  }
+  const entries = [...response.data.entries].sort(compareFilesystemEntries);
+  const lines = entries.map(
+    (entry) => options.long === true ? formatLongFilesystemEntryLine(entry) : formatShellFilesystemEntryName(entry)
+  );
+  if (lines.length > 0) {
+    output.raw(lines.join("\n"));
+  } else {
+    output.warning(`No entries under ${formatCatalogPathForDisplay(response.data.path)}.`);
+  }
+  if (response.data.truncated) {
+    output.warning(`[truncated: ${response.data.total_entries} total entries]`);
+  }
+}
+async function runKnowTreeCommand(path, options, output, dependencies) {
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const response = await api.tree({
+    path: normalizeFilesystemCatalogPath(path ?? "/"),
+    depth: coerceLimit(options.depth, 3, 8),
+    limit: coerceLimit(options.limit, 500, 2e3)
+  });
+  if (shouldPrintJson(options)) {
+    output.raw(formatJson(response.data));
+    return;
+  }
+  const lines = formatFilesystemTree(response.data.path, response.data.entries);
+  output.raw(lines.join("\n"));
+  if (response.data.truncated) {
+    output.warning(`[truncated: ${response.data.total_entries} total entries]`);
+  }
+}
+async function runKnowFindCommand(path, options, output, dependencies) {
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const response = await api.find({
+    path: normalizeFilesystemCatalogPath(path ?? "/"),
+    name: options.name,
+    type: options.type,
+    maxDepth: coerceOptionalFiniteNumber(options.maxDepth),
+    limit: coerceLimit(options.limit, 500, 2e3)
+  });
+  if (shouldPrintJson(options)) {
+    output.raw(formatJson(response.data));
+    return;
+  }
+  const entries = [...response.data.entries].sort(compareFilesystemEntries);
+  const lines = entries.map(formatFilesystemEntryPath);
+  if (lines.length > 0) {
+    output.raw(lines.join("\n"));
+  } else {
+    output.warning(`No entries found under ${formatCatalogPathForDisplay(response.data.path)}.`);
+  }
+  if (response.data.truncated) {
+    output.warning(`[truncated: ${response.data.total_entries} total entries]`);
+  }
+}
+async function runKnowStatCommand(path, options, output, dependencies) {
+  if (!path) {
+    throw new Error("Missing path. Usage: cngkit knowledges stat <path>");
+  }
+  const api = dependencies?.api ?? createKnowledgesApi(options);
+  const response = await api.statPath({
+    path: normalizeFilesystemCatalogPath(path)
+  });
+  if (shouldPrintJson(options)) {
+    output.raw(formatJson(response.data));
+    return;
+  }
+  output.raw(formatFilesystemStat(response.data));
+}
+async function runKnowRealpathCommand(path, options, output) {
+  if (!path) {
+    throw new Error("Missing path. Usage: cngkit knowledges realpath <path>");
+  }
+  const resolvedPath = formatCatalogPathForDisplay(normalizeFilesystemCatalogPath(path));
+  if (shouldPrintJson(options)) {
+    output.raw(formatJson({ path: resolvedPath }));
+    return;
+  }
+  output.raw(resolvedPath);
+}
+function compareFilesystemEntries(left, right) {
+  if (left.type !== right.type) {
+    return left.type === "directory" ? -1 : 1;
+  }
+  return left.path.localeCompare(right.path);
+}
+function outputRawContent(data, options, output) {
+  if (shouldPrintJson(options)) {
+    output.raw(formatJson(data));
+    return;
+  }
+  output.raw(data.content);
+}
+function formatFilesystemTree(rootPath, entries) {
+  const normalizedRootPath = rootPath.replace(/\/+$/, "");
+  const rootLine = formatTreeDirectoryName(rootPath);
+  const entryLines = [...entries].sort(compareFilesystemEntries).map((entry) => {
+    const relativePath = stripRootPath(entry.path, normalizedRootPath);
+    const segmentCount = relativePath.split("/").filter(Boolean).length;
+    const indent = "  ".repeat(Math.max(segmentCount - 1, 0));
+    return `${indent}${formatShellFilesystemEntryName(entry)}`;
+  });
+  return [rootLine, ...entryLines];
+}
+function stripRootPath(path, rootPath) {
+  if (path === rootPath) {
+    return "";
+  }
+  if (rootPath && path.startsWith(`${rootPath}/`)) {
+    return path.slice(rootPath.length + 1);
+  }
+  return path;
+}
+function formatTreeDirectoryName(path) {
+  const normalizedPath = formatCatalogPathForDisplay(path).replace(/\/+$/, "");
+  return normalizedPath ? `${normalizedPath}/` : "/";
+}
+function formatShellFilesystemEntryName(entry) {
+  return entry.type === "directory" ? `${entry.name}/` : entry.name;
+}
+function formatFilesystemEntryPath(entry) {
+  const displayPath = formatCatalogPathForDisplay(entry.path);
+  return entry.type === "directory" ? `${displayPath}/` : displayPath;
+}
+function formatLongFilesystemEntryLine(entry) {
+  const fields = [
+    entry.type,
+    formatCatalogPathForDisplay(entry.path),
+    ...formatOptionalEntryFields([
+      ["size", entry.size],
+      ["files", entry.file_count],
+      ["children", entry.child_count],
+      ["total_size", entry.total_size],
+      ["sha256", entry.sha256],
+      ["asset_kind", entry.asset_kind],
+      ["topic", entry.topic_name]
+    ])
+  ];
+  return fields.join("	");
+}
+function coerceOptionalFiniteNumber(value) {
+  const normalizedValue = coerceOptionalNumber(value);
+  return normalizedValue === void 0 || Number.isNaN(normalizedValue) ? void 0 : Math.max(1, Math.trunc(normalizedValue));
+}
+function formatFilesystemStat(entry) {
+  const fields = [
+    ["path", formatCatalogPathForDisplay(entry.path)],
+    ["type", entry.type],
+    ["name", entry.name],
+    ["depth", entry.depth],
+    ["size", entry.size],
+    ["files", entry.file_count],
+    ["children", entry.child_count],
+    ["total_size", entry.total_size],
+    ["sha256", entry.sha256],
+    ["asset_kind", entry.asset_kind],
+    ["title", entry.title],
+    ["topic", entry.topic_name],
+    ["updated_at", entry.updated_at]
+  ];
+  return formatOptionalEntryFields(fields).join("\n");
+}
+function formatOptionalEntryFields(fields) {
+  return fields.flatMap(([key, value]) => {
+    if (value === null || value === "") {
+      return [];
+    }
+    return [`${key}=${value}`];
+  });
+}
+
+export {
+  runKnowStatusCommand,
+  runKnowAudiencesCommand,
+  runKnowSearchCommand,
+  runKnowListCommand,
+  runKnowFilesCommand,
+  runKnowReadCommand,
+  runKnowCatCommand,
+  runKnowHeadCommand,
+  runKnowTailCommand,
+  runKnowGrepCommand,
+  runKnowGlobCommand,
+  runKnowLsCommand,
+  runKnowTreeCommand,
+  runKnowFindCommand,
+  runKnowStatCommand,
+  runKnowRealpathCommand
+};
+//# sourceMappingURL=chunk-NODJM6SH.js.map