deepline 0.3.395 → 0.3.397

package/dist/cli/chunk-FIVKWNMT.mjs

@@ -0,0 +1,210 @@
+// 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;
+    }
+  }
+  const roots = candidateRoots(payload);
+  const v2Raw = roots.find((root) => root.path === "toolResponse.raw");
+  for (const root of v2Raw ? [v2Raw] : roots) {
+    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 {};
+}
+
+export {
+  tryConvertToList,
+  projectRowOutput,
+  writeJsonOutputFile,
+  writeCsvOutputFile,
+  extractSummaryFields
+};

package/dist/cli/{describe-DBRY5BNK.mjs → chunk-HFYQBC2D.mjs}

@@ -1,57 +1,22 @@
-import {
-  buildPlayDashboardUrl,
-  describedPlay
-} from "./chunk-XMAPE2KH.mjs";
-import "./chunk-3TRY7KAC.mjs";
 import {
   describedTool,
   formatModelDescription,
   publicToolSchemas,
   toolMetadataJsonForDescribe
-} from "./chunk-EFLQHJZ6.mjs";
+} from "./chunk-YHZUZO3U.mjs";
 import {
-  SCHEMA_LINE_LIMIT,
-  addDescribeOptions,
+  buildPlayDashboardUrl,
   byokLines,
   describedJson,
   describedLines,
+  describedPlay,
   examples,
   schemaLines,
   topLevelField
-} from "./chunk-VB6KECLU.mjs";
-import "./chunk-OVDNJAJN.mjs";
-import "./chunk-3HWALOL2.mjs";
-import "./chunk-H7HIDGZ7.mjs";
-import "./chunk-HQXL5526.mjs";
-import "./chunk-7XAM7KDW.mjs";
-import "./chunk-ERFN2QY4.mjs";
-import "./chunk-KZZC33PY.mjs";
-import "./chunk-3HU47EGZ.mjs";
-import {
-  DeeplineClient
-} from "./chunk-G4IWGRMK.mjs";
-import "./chunk-6IKARAYD.mjs";
-import "./chunk-JI2B4RZP.mjs";
-import "./chunk-5VCZ3WRH.mjs";
-import "./chunk-UBKA33KY.mjs";
-import "./chunk-UFS752TU.mjs";
-import "./chunk-GAMFK2ZP.mjs";
-import "./chunk-WXLOW623.mjs";
-import {
-  printCommandEnvelope
-} from "./chunk-47M6HPGP.mjs";
-import "./chunk-6D7A2FSL.mjs";
-import "./chunk-DLIRSHV6.mjs";
+} from "./chunk-IHG7UAHD.mjs";
 import {
   DeeplineError
 } from "./chunk-NXGCO4JB.mjs";
-import "./chunk-BON3DRC6.mjs";
-import "./chunk-WZYKRD7T.mjs";
-import "./chunk-KRD6H754.mjs";
-
-// src/cli/commands/describe.ts
-import { writeFileSync } from "fs";
-import { resolve } from "path";
 
 // src/cli/tool-features.ts
 var VIEWS = {
@@ -116,7 +81,7 @@ async function describeFeature(tool, feature, value, dependencies) {
   return VIEWS[feature.view](value ?? feature.defaultValue, tool, dependencies);
 }
 
-// src/cli/commands/describe.ts
+// src/cli/describe-core.ts
 var FILTER_OF = {
   tool: "tools",
   monitor_type: "monitors",
@@ -133,12 +98,20 @@ async function found(lookup) {
     throw error;
   }
 }
-async function describeAnything(name, options, onMissing) {
+function describeLookupsFor(client) {
+  return {
+    play: (reference) => found(client.describePlay(reference)),
+    tool: (name) => found(client.getTool(name)),
+    describeModel: (model) => client.describeModel(model),
+    baseUrl: client.baseUrl
+  };
+}
+async function describeName(name, options, lookups) {
   const maintainedOnly = options.prebuilt === true || options.tool === true;
   const wants = (filter) => (!options.kinds || options.kinds.includes(filter)) && !(maintainedOnly && filter === "custom");
-  const client = new DeeplineClient();
   const play = async (reference) => {
-    const record2 = await client.describePlay(reference);
+    const record2 = await lookups.play(reference);
+    if (!record2) return null;
     return {
       described: describedPlay(record2),
       record: { ...record2 },
@@ -149,7 +122,8 @@ async function describeAnything(name, options, onMissing) {
     };
   };
   const tool = async () => {
-    const record2 = options.fetchedTool ?? await client.getTool(name);
+    const record2 = await lookups.tool(name);
+    if (!record2) return null;
     const { byok } = record2;
     const features = toolFeatures(record2);
     return {
@@ -160,12 +134,16 @@ async function describeAnything(name, options, onMissing) {
         ...byok?.required === true ? { byok } : {},
         ...features.length ? { features: features.map(({ view: _view, ...feature }) => feature) } : {}
       },
-      record: toolMetadataJsonForDescribe(record2, name),
+      record: toolMetadataJsonForDescribe(
+        record2,
+        name,
+        lookups.seedStarterScript
+      ),
       schemas: publicToolSchemas(record2),
       feature: (featureName, value) => {
         const feature = features.find(({ name: name2 }) => name2 === featureName);
         return feature ? describeFeature(record2, feature, value, {
-          describeModel: (model) => client.describeModel(model)
+          describeModel: (model) => lookups.describeModel(model)
         }) : null;
       }
     };
@@ -177,19 +155,13 @@ async function describeAnything(name, options, onMissing) {
   ];
   const matches = await Promise.all(
     sources.filter((source) => source.kinds.some(wants)).map(async ({ kinds, find }) => {
-      const match = await found(find());
+      const match = await find();
       const filter = match && FILTER_OF[match.described.kind];
       return filter && kinds.includes(filter) && wants(filter) ? match : null;
     })
   );
   const [chosen, shadowed] = matches.filter((match) => match !== null);
-  if (!chosen) {
-    if (onMissing) return onMissing();
-    console.error(
-      `Nothing named "${name}". Search for it: deepline search ${JSON.stringify(name.replace(/[-_./]+/g, " "))}`
-    );
-    return 2;
-  }
+  if (!chosen) return { status: "missing" };
   const { described, record } = chosen;
   const shadows = described.kind === "custom_play" && shadowed ? {
     kind: shadowed.described.kind,
@@ -197,49 +169,49 @@ async function describeAnything(name, options, onMissing) {
   } : null;
   const note = shadows ? `Showing your workspace play "${name}". It has the same name as a Deepline ${shadows.kind.replace("_", " ")}; see that one with: ${shadows.describeCommand}` : null;
   const verbose = options.verbose === true;
-  const json = options.json === true;
   const isPlay = described.kind === "prebuilt_play" || described.kind === "custom_play";
-  const dashboardUrl = isPlay ? buildPlayDashboardUrl(client.baseUrl, described.id) : null;
+  const dashboardUrl = isPlay ? buildPlayDashboardUrl(lookups.baseUrl, described.id) : null;
   if (options.webUrl) {
     if (!dashboardUrl) {
-      console.error(
-        `${described.id} is a ${described.kind.replace("_", " ")}, not a play; only plays have a play page.`
-      );
-      return 1;
+      return {
+        status: "refused",
+        message: `${described.id} is a ${described.kind.replace("_", " ")}, not a play; only plays have a play page.`,
+        exitCode: 1
+      };
     }
-    printCommandEnvelope(
-      { dashboardUrl },
-      { json, text: `${dashboardUrl}
-` }
-    );
-    return 0;
+    return {
+      status: "described",
+      envelope: { dashboardUrl },
+      lines: [dashboardUrl]
+    };
   }
   if (options.feature !== void 0) {
     const { name: featureName, value } = parseFeatureRequest(options.feature);
     const pending = chosen.feature?.(featureName, value) ?? null;
     const features = described.features ?? [];
     if (!pending) {
-      console.error(
-        features.length ? `${described.id} has no feature "${featureName}". Its features: ${features.map(({ name: name2 }) => name2).join(", ")}.` : `${described.id} has no features to describe.`
-      );
-      return 2;
+      return {
+        status: "refused",
+        message: features.length ? `${described.id} has no feature "${featureName}". Its features: ${features.map(({ name: name2 }) => name2).join(", ")}.` : `${described.id} has no features to describe.`,
+        exitCode: 2
+      };
     }
     const shownValue = value ?? features.find(({ name: name2 }) => name2 === featureName)?.defaultValue;
     const { details, lines } = await pending;
-    return deliver(
-      {
+    return {
+      status: "described",
+      envelope: {
         kind: described.kind,
         id: described.id,
         feature: featureName,
         ...shownValue ? { value: shownValue } : {},
         details
       },
-      [
+      lines: [
         `${described.id} --feature ${featureName}${shownValue ? `=${shownValue}` : ""}`,
         ...lines
-      ],
-      { json, out: options.out }
-    );
+      ]
+    };
   }
   const fields = (options.fields ?? "").split(",").map((name2) => name2.trim()).filter(Boolean);
   const named = options.cliExample === true || options.playExample === true;
@@ -305,102 +277,10 @@ async function describeAnything(name, options, onMissing) {
     ...dashboardUrl ? { dashboardUrl } : {},
     ...shadows ? { shadows, note } : {}
   };
-  return deliver(envelope, view.lines, { json, out: options.out });
-}
-function deliver(envelope, lines, { json, out }) {
-  const text = `${lines.join("\n")}
-`;
-  if (out) {
-    const path = resolve(out);
-    const content = json ? `${JSON.stringify(envelope, null, 2)}
-` : text;
-    writeFileSync(path, content);
-    const bytes = Buffer.byteLength(content);
-    printCommandEnvelope(
-      { path, bytes },
-      { json, text: `Wrote ${path} (${bytes} bytes)
-` }
-    );
-    return 0;
-  }
-  printCommandEnvelope(envelope, { json, text });
-  return 0;
+  return { status: "described", envelope, lines: view.lines };
 }
-function registerDescribeCommand(program) {
-  addDescribeOptions(program.command("describe <name>")).option("--web-url", "Print only a play's play page URL").description(
-    "Describe anything search returns: a tool, monitor type, or play."
-  ).addHelpText(
-    "after",
-    `
-What you can describe:
-  Any id deepline search returns: a tool id, a monitor type id, or a play name
-  or reference. You do not say which kind it is; tool ids, monitor type ids
-  and prebuilt play names never overlap.
-
-When a name is taken twice:
-  A play your workspace created is shown instead of a Deepline tool, monitor
-  type or prebuilt play with the same name, and the output says so.
-  Pass --prebuilt (or --tool) to see the Deepline one.
-
-What it prints:
-  The same sections for every kind: what it is, cost, inputs, outputs, then
-  an example of running it from the CLI and from inside a play.
 
-Examples in the output:
-  (default)        required inputs filled in, first output read
-  --verbose        every input filled in, every output read; also shows
-                   secondary fields
-  --cli-example    only the CLI example, with how inputs and outputs work
-  --play-example   only the in-play example, with how inputs and outputs work
-  --no-example     no examples
-
-Features:
-  A tool lists its features: parts with their own description, such as the
-  model an AI tool runs. --feature <name> describes one at its default value,
-  --feature <name>=<value> at another, e.g. --feature model=openai/gpt-5.6-luna.
-
-Schema size and format:
-  Secondary fields (diagnostics, attempt logs, echoes of input) are left out
-  by default; the output names them, and --verbose shows them.
-  --fields email,miss_reason shows only the fields you name, plus every
-  required input, and names the rest. Use it when you know what you need.
-  A schema over ${SCHEMA_LINE_LIMIT} lines is folded: deeper objects show only their field
-  names. A shape used more than once is printed once under Types.
-  --full-schema    the normal output, with the schema not folded
-  --schema-only    only the schema, not folded, and nothing else
-  --json           the same facts as JSON: fields keyed by name, with what
-                   each means and, for a tool, where it is in the result;
-                   secondary fields are named in "hidden"
-  --json --full-schema  the whole catalog record, as tools describe and
-                   plays describe print it
-  --schema-only --json
-                   only the input and output JSON Schemas; use this for a
-                   program, or for a schema too large to read
-  --out <path>     save any of the above to a file instead of printing it
-
-Play page:
-  For a play, the output ends with its play page URL (JSON: dashboardUrl).
-  --web-url        print only that URL; with --json, {"dashboardUrl": ...}.
-                   Fails for a tool or monitor type, which have no play page.
-
-Older commands:
-  deepline tools describe and deepline plays describe are this command limited
-  to one kind. Their own flags still work: --pricing-only, --examples-only,
-  --model and --estimate-payload on tools; --json <fields> on plays.
-
-Examples:
-  deepline describe hunter_email_verifier
-  deepline describe person-linkedin-to-email
-  deepline describe my-play --prebuilt
-  deepline describe ai_ark_people_search --full-schema
-  deepline describe prebuilt/person-to-email-batch --web-url
-  deepline describe ai_ark_people_search --schema-only --out schema.json
-`
-  ).action(async (name, options) => {
-    process.exitCode = await describeAnything(name, options);
-  });
-}
 export {
-  describeAnything,
-  registerDescribeCommand
+  describeLookupsFor,
+  describeName
 };