deepline 0.3.294 → 0.3.295

package/dist/cli/chunk-MIMASXO4.mjs

@@ -0,0 +1,389 @@
+// src/tool-output.ts
+import {
+  closeSync,
+  mkdirSync,
+  openSync,
+  writeFileSync,
+  writeSync
+} from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function getByDottedPath(root, dottedPath) {
+  let current = root;
+  for (const segment of String(dottedPath || "").split(".").filter(Boolean)) {
+    if (!isPlainObject(current) || !(segment in current)) {
+      return null;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function normalizeRows(value) {
+  if (!Array.isArray(value)) return null;
+  return value.map((entry) => {
+    if (isPlainObject(entry)) return entry;
+    return { value: entry };
+  });
+}
+function columnsForRows(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  const columns = [];
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      if (!seen.has(key)) {
+        seen.add(key);
+        columns.push(key);
+      }
+    }
+  }
+  return columns;
+}
+function candidateRoots(payload) {
+  const roots = [
+    { path: null, value: payload }
+  ];
+  if (isPlainObject(payload) && isPlainObject(payload.toolResponse)) {
+    roots.push({ path: "toolResponse", value: payload.toolResponse });
+    if (Object.prototype.hasOwnProperty.call(payload.toolResponse, "raw")) {
+      roots.push({
+        path: "toolResponse.raw",
+        value: payload.toolResponse.raw
+      });
+    }
+  }
+  if (isPlainObject(payload) && isPlainObject(payload.output)) {
+    roots.push({ path: "output", value: payload.output });
+    if (Object.prototype.hasOwnProperty.call(payload.output, "body")) {
+      roots.push({ path: "output.body", value: payload.output.body });
+    }
+  }
+  if (isPlainObject(payload) && isPlainObject(payload.result)) {
+    roots.push({ path: "result", value: payload.result });
+    if (isPlainObject(payload.result.data)) {
+      roots.push({ path: "result.data", value: payload.result.data });
+    }
+  }
+  return roots;
+}
+function findBestArrayCandidate(value, pathPrefix = "", depth = 0) {
+  if (depth > 5) return null;
+  const directRows = normalizeRows(value);
+  const hasObjectRow = directRows?.some(
+    (row) => Object.keys(row).some((key) => key !== "value")
+  ) ?? false;
+  let best = directRows && directRows.length > 0 && hasObjectRow ? { path: pathPrefix, rows: directRows } : null;
+  if (!isPlainObject(value)) {
+    return best;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    const childPath = pathPrefix ? `${pathPrefix}.${key}` : key;
+    const candidate = findBestArrayCandidate(child, childPath, depth + 1);
+    if (!candidate) continue;
+    if (!best || candidate.rows.length > best.rows.length) {
+      best = candidate;
+    }
+  }
+  return best;
+}
+function tryConvertToList(payload, options) {
+  const listExtractorPaths = Array.isArray(options?.listExtractorPaths) ? options?.listExtractorPaths.filter(
+    (entry) => typeof entry === "string" && entry.trim().length > 0
+  ) : [];
+  if (listExtractorPaths.length > 0) {
+    let emptyMatch = null;
+    for (const root of candidateRoots(payload)) {
+      for (const extractorPath of listExtractorPaths) {
+        const resolved = getByDottedPath(root.value, extractorPath);
+        const rows = normalizeRows(resolved);
+        if (!rows) {
+          continue;
+        }
+        const sourcePath = root.path ? `${root.path}.${extractorPath}` : extractorPath;
+        if (rows.length > 0) {
+          return { rows, strategy: "configured_paths", sourcePath };
+        }
+        emptyMatch ??= { rows, strategy: "configured_paths", sourcePath };
+      }
+    }
+    if (emptyMatch) {
+      return emptyMatch;
+    }
+  }
+  for (const root of candidateRoots(payload)) {
+    const candidate = findBestArrayCandidate(root.value, root.path ?? "");
+    if (!candidate || candidate.rows.length === 0) continue;
+    return {
+      rows: candidate.rows,
+      strategy: "auto_detected",
+      sourcePath: candidate.path || root.path
+    };
+  }
+  return null;
+}
+function projectRowOutput(conversion) {
+  return {
+    rows: conversion.rows,
+    rowCount: conversion.rows.length,
+    columns: columnsForRows(conversion.rows),
+    previewRows: conversion.rows.slice(0, 5),
+    strategy: conversion.strategy,
+    sourcePath: conversion.sourcePath
+  };
+}
+function ensureOutputDir() {
+  const outputDir = join(homedir(), ".local", "share", "deepline", "data");
+  mkdirSync(outputDir, { recursive: true });
+  return outputDir;
+}
+function writeJsonOutputFile(payload, stem) {
+  const outputDir = ensureOutputDir();
+  const outputPath = join(outputDir, `${stem}_${Date.now()}.json`);
+  writeFileSync(outputPath, JSON.stringify(payload, null, 2), "utf-8");
+  return outputPath;
+}
+function writeCsvOutputFile(rows, stem, options) {
+  const outputPath = options?.outPath ? options.outPath : join(ensureOutputDir(), `${stem}_${Date.now()}.csv`);
+  mkdirSync(dirname(outputPath), { recursive: true });
+  const columns = columnsForRows(rows);
+  const escapeCell = (value) => {
+    const normalized = value == null ? "" : typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? String(value) : JSON.stringify(value);
+    if (/[",\n]/.test(normalized)) {
+      return `"${normalized.replace(/"/g, '""')}"`;
+    }
+    return normalized;
+  };
+  const fd = openSync(outputPath, "w");
+  try {
+    writeSync(fd, `${columns.map(escapeCell).join(",")}
+`);
+    for (const row of rows) {
+      writeSync(
+        fd,
+        `${columns.map((column) => escapeCell(row[column])).join(",")}
+`
+      );
+    }
+  } finally {
+    closeSync(fd);
+  }
+  const previewRows = rows.slice(0, 5);
+  const previewColumns = columns.slice(0, 5);
+  const preview = [
+    previewColumns.join(","),
+    ...previewRows.map(
+      (row) => previewColumns.map((column) => escapeCell(row[column])).join(",")
+    )
+  ].join("\n");
+  return {
+    path: outputPath,
+    rowCount: rows.length,
+    columns,
+    preview
+  };
+}
+function extractSummaryFields(payload) {
+  const candidates = candidateRoots(payload);
+  for (const candidate of candidates) {
+    if (!isPlainObject(candidate.value)) continue;
+    const summaryEntries = Object.entries(candidate.value).filter(
+      ([, value]) => {
+        return value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+      }
+    );
+    if (summaryEntries.length === 0) continue;
+    return Object.fromEntries(summaryEntries);
+  }
+  return {};
+}
+
+// ../plays/row-identity.ts
+var POSTGRES_IDENTIFIER_MAX_LENGTH = 63;
+var MAP_KEY_NAMESPACE_MAX_LENGTH = POSTGRES_IDENTIFIER_MAX_LENGTH;
+var SHA256_INITIAL_HASH = [
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+];
+var SHA256_ROUND_CONSTANTS = [
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+];
+function stableValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => stableValue(entry));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, entry]) => entry !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, stableValue(entry)])
+    );
+  }
+  return value;
+}
+function stableStringify(value) {
+  return JSON.stringify(stableValue(value));
+}
+function rightRotate32(value, bits) {
+  return value >>> bits | value << 32 - bits;
+}
+function sha256Hex(input) {
+  const bytes = Array.from(new TextEncoder().encode(input));
+  const bitLength = bytes.length * 8;
+  bytes.push(128);
+  while (bytes.length % 64 !== 56) {
+    bytes.push(0);
+  }
+  const highBits = Math.floor(bitLength / 4294967296);
+  const lowBits = bitLength >>> 0;
+  bytes.push(
+    highBits >>> 24 & 255,
+    highBits >>> 16 & 255,
+    highBits >>> 8 & 255,
+    highBits & 255,
+    lowBits >>> 24 & 255,
+    lowBits >>> 16 & 255,
+    lowBits >>> 8 & 255,
+    lowBits & 255
+  );
+  const hash = [...SHA256_INITIAL_HASH];
+  const words = new Array(64).fill(0);
+  for (let offset = 0; offset < bytes.length; offset += 64) {
+    for (let index = 0; index < 16; index += 1) {
+      const wordOffset = offset + index * 4;
+      words[index] = (bytes[wordOffset] ?? 0) << 24 | (bytes[wordOffset + 1] ?? 0) << 16 | (bytes[wordOffset + 2] ?? 0) << 8 | (bytes[wordOffset + 3] ?? 0);
+    }
+    for (let index = 16; index < 64; index += 1) {
+      const s0 = rightRotate32(words[index - 15], 7) ^ rightRotate32(words[index - 15], 18) ^ words[index - 15] >>> 3;
+      const s1 = rightRotate32(words[index - 2], 17) ^ rightRotate32(words[index - 2], 19) ^ words[index - 2] >>> 10;
+      words[index] = words[index - 16] + s0 + words[index - 7] + s1 >>> 0;
+    }
+    let [a, b, c, d, e, f, g, h] = hash;
+    for (let index = 0; index < 64; index += 1) {
+      const s1 = rightRotate32(e, 6) ^ rightRotate32(e, 11) ^ rightRotate32(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = h + s1 + ch + SHA256_ROUND_CONSTANTS[index] + words[index] >>> 0;
+      const s0 = rightRotate32(a, 2) ^ rightRotate32(a, 13) ^ rightRotate32(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = s0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    hash[0] = hash[0] + a >>> 0;
+    hash[1] = hash[1] + b >>> 0;
+    hash[2] = hash[2] + c >>> 0;
+    hash[3] = hash[3] + d >>> 0;
+    hash[4] = hash[4] + e >>> 0;
+    hash[5] = hash[5] + f >>> 0;
+    hash[6] = hash[6] + g >>> 0;
+    hash[7] = hash[7] + h >>> 0;
+  }
+  return hash.map((word) => word.toString(16).padStart(8, "0")).join("");
+}
+function sanitizeIdentifierPart(value) {
+  return value.trim().replace(/[^a-z0-9]+/gi, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
+}
+function validateIdentifierPart(rawValue, label, maxLength) {
+  const sanitized = sanitizeIdentifierPart(rawValue);
+  if (!sanitized) {
+    throw new Error(`${label} must contain a letter or number.`);
+  }
+  if (sanitized.length > maxLength) {
+    throw new Error(
+      `${label} is too long after normalization (${sanitized.length}/${maxLength}): "${sanitized}".`
+    );
+  }
+  return sanitized;
+}
+function normalizeTableNamespace(value) {
+  return validateIdentifierPart(
+    value,
+    "ctx.dataset() key",
+    MAP_KEY_NAMESPACE_MAX_LENGTH
+  );
+}
+
+export {
+  stableStringify,
+  sha256Hex,
+  normalizeTableNamespace,
+  tryConvertToList,
+  projectRowOutput,
+  writeJsonOutputFile,
+  writeCsvOutputFile,
+  extractSummaryFields
+};

package/dist/cli/chunk-MROPCKW2.mjs

@@ -0,0 +1,190 @@
+import {
+  DeeplineClient
+} from "./chunk-XL2FO6CW.mjs";
+import {
+  printCommandEnvelope
+} from "./chunk-6O5YZOVN.mjs";
+import {
+  resolveConfig,
+  sdkCliStateDirPath
+} from "./chunk-EACVZI6N.mjs";
+
+// src/cli/search-ref.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+var SEARCH_REF_TTL_MS = 15 * 6e4;
+function lastSearchPath() {
+  return join(sdkCliStateDirPath(resolveConfig().baseUrl), "last-search.json");
+}
+function rememberSearchRef(searchRef) {
+  try {
+    mkdirSync(dirname(lastSearchPath()), { recursive: true });
+    writeFileSync(
+      lastSearchPath(),
+      JSON.stringify({ searchRef, at: Date.now() }),
+      { mode: 384 }
+    );
+  } catch {
+  }
+}
+function recentSearchRef() {
+  try {
+    const saved = JSON.parse(readFileSync(lastSearchPath(), "utf8"));
+    return typeof saved.searchRef === "string" && typeof saved.at === "number" && Date.now() - saved.at < SEARCH_REF_TTL_MS ? saved.searchRef : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/cli/commands/search.ts
+var SEARCH_TYPES = [
+  "tools",
+  "plays",
+  "monitors",
+  "prebuilts",
+  "custom"
+];
+var USAGE = "Usage: deepline search [query] [--type <types>] [--categories <categories>] [--search_terms <terms>] [--json]";
+function parseTypes(flag, raw) {
+  const names = (raw ?? "").split(",").map((name) => name.trim().toLowerCase()).filter(Boolean);
+  const unknown = names.filter(
+    (name) => !SEARCH_TYPES.includes(name)
+  );
+  if (unknown.length > 0) {
+    throw new Error(
+      `Unknown ${flag} ${unknown.join(", ")}. Use any of: ${SEARCH_TYPES.join(", ")}.`
+    );
+  }
+  return names;
+}
+function optionalInteger(raw) {
+  return raw === void 0 ? void 0 : Number.parseInt(raw, 10);
+}
+function appendCsv(value, previous) {
+  return previous ? `${previous},${value}` : value;
+}
+function addSearchOptions(command) {
+  return command.option(
+    "--categories <categories>",
+    "Comma-separated tool categories; may be used without a query"
+  ).option(
+    "--search_terms <terms>",
+    "Comma-separated structured search terms; may be used without a query"
+  ).option("--search-terms <terms>", "Alias for --search_terms").option(
+    "--task <sentence>",
+    "What you are trying to accomplish: input you have -> result you need"
+  ).option("--limit <count>", "Maximum ranked results to return (1-50)").option("--offset <count>", "Zero-based ranked result offset").option("--search-mode <mode>", "Ranked search mode: v1 or v2").option("--include-search-debug", "Include ranked search debug metadata").option("--json", "Emit JSON output instead of the readable default");
+}
+async function runSearch(queryInput, options, types, exclude = []) {
+  const query = queryInput?.trim() ?? "";
+  const searchTerms = options.searchTerms ?? options.search_terms;
+  if (!query && !options.categories?.trim() && !searchTerms?.trim()) {
+    console.error(USAGE);
+    return 1;
+  }
+  const { search_ref: searchRef, ...result } = await new DeeplineClient().search({
+    query,
+    types,
+    exclude,
+    categories: options.categories,
+    searchTerms,
+    task: options.task,
+    limit: optionalInteger(options.limit),
+    offset: optionalInteger(options.offset),
+    searchMode: options.searchMode === "v1" || options.searchMode === "v2" ? options.searchMode : void 0,
+    includeSearchDebug: Boolean(options.includeSearchDebug)
+  });
+  if (searchRef) rememberSearchRef(searchRef);
+  printCommandEnvelope(result, {
+    json: options.json === true
+  });
+  return 0;
+}
+function registerDeprecatedSearchCommand(parent, typesFor) {
+  const name = `deepline ${parent.name()} search`;
+  addSearchOptions(
+    parent.command("search [query]").description(`Deprecated. Use deepline search --type <types>.`).addHelpText(
+      "after",
+      `
+Notes:
+  Deprecated alias for the unified search. It runs deepline search with the
+  matching --type and returns the same results envelope.
+
+Examples:
+  deepline search email --type ${typesFor({}).join(",")}
+`
+    ).option("--all", "Include plays your workspace created").option("--compact", "Accepted for compatibility; results are compact")
+  ).action(async (query, options) => {
+    const types = typesFor(options);
+    console.error(
+      `${name} is deprecated. Use: deepline search${query ? ` ${JSON.stringify(query)}` : ""} --type ${types.join(",")}`
+    );
+    process.exitCode = await runSearch(query, options, types);
+  });
+}
+function registerSearchCommand(program) {
+  addSearchOptions(
+    program.command("search [query]").description(
+      "Search tools, monitors, and plays together, ranked by intent."
+    ).addHelpText(
+      "after",
+      `
+Notes:
+  One ranked search across everything Deepline can run, deploy, or explain.
+  Every result carries a kind: tool, monitor_type, prebuilt_play, custom_play
+  (a play your workspace created), or doc. Narrow with --type, a
+  comma-separated list of:
+    tools      atomic provider operations (deepline tools execute)
+    monitors   monitor types you can deploy
+    prebuilts  Deepline-maintained plays
+    custom     plays your workspace created
+    plays      prebuilts and custom together
+  --exclude takes the same names and leaves those kinds out instead.
+  Ranking uses a third-party AI relevance model. For plays your workspace
+  created it is sent only the play name and description, never play code.
+  Both flags may be repeated: --type tools --type prebuilts.
+  Provide a query, or omit it only when --categories and/or --search_terms is
+  supplied. Use --limit and --offset to page (limit 1-50, offset zero-based);
+  JSON includes next_offset. Pass --task with one sentence on what you are
+  trying to accomplish: the input you have and the result you need. It
+  materially improves ranking, especially for short queries.
+  Search prints a readable result list by default, piped or not, and that is
+  the recommended form. Pass --json only when a program parses the result.
+
+Examples:
+  deepline search "find work email"
+  deepline search "find work email" --type tools --limit 10
+  deepline search "company to contacts" --type plays
+  deepline search "enrich a company" --exclude monitors,custom
+  deepline search linkedin --task "I have 200 LinkedIn profile URLs and need each person's current title and company"
+  deepline search --type tools --categories company_search --search_terms "investors,funding"
+`
+    ).option(
+      "--type <types>",
+      `Kinds to search, comma-separated or repeated: ${SEARCH_TYPES.join(", ")}`,
+      appendCsv
+    ).option(
+      "--exclude <types>",
+      "Kinds to leave out, comma-separated or repeated; the opposite of --type",
+      appendCsv
+    )
+  ).action(async (query, options) => {
+    let types;
+    let exclude;
+    try {
+      types = parseTypes("--type", options.type);
+      exclude = parseTypes("--exclude", options.exclude);
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exitCode = 1;
+      return;
+    }
+    process.exitCode = await runSearch(query, options, types, exclude);
+  });
+}
+
+export {
+  recentSearchRef,
+  registerDeprecatedSearchCommand,
+  registerSearchCommand
+};