deepline 0.3.395 → 0.3.397

package/dist/cli/chunk-HGFFYVXN.js

@@ -0,0 +1,210 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/tool-output.ts
+
+
+
+
+
+
+var _fs = require('fs');
+var _os = require('os');
+var _path = require('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 = _nullishCoalesce(_optionalChain([directRows, 'optionalAccess', _ => _.some, 'call', _2 => _2(
+    (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(_optionalChain([options, 'optionalAccess', _3 => _3.listExtractorPaths])) ? _optionalChain([options, 'optionalAccess', _4 => _4.listExtractorPaths, 'access', _5 => _5.filter, 'call', _6 => _6(
+    (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, _nullishCoalesce(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 = _path.join.call(void 0, _os.homedir.call(void 0, ), ".local", "share", "deepline", "data");
+  _fs.mkdirSync.call(void 0, outputDir, { recursive: true });
+  return outputDir;
+}
+function writeJsonOutputFile(payload, stem) {
+  const outputDir = ensureOutputDir();
+  const outputPath = _path.join.call(void 0, outputDir, `${stem}_${Date.now()}.json`);
+  _fs.writeFileSync.call(void 0, outputPath, JSON.stringify(payload, null, 2), "utf-8");
+  return outputPath;
+}
+function writeCsvOutputFile(rows, stem, options) {
+  const outputPath = _optionalChain([options, 'optionalAccess', _7 => _7.outPath]) ? options.outPath : _path.join.call(void 0, ensureOutputDir(), `${stem}_${Date.now()}.csv`);
+  _fs.mkdirSync.call(void 0, _path.dirname.call(void 0, 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 = _fs.openSync.call(void 0, outputPath, "w");
+  try {
+    _fs.writeSync.call(void 0, fd, `${columns.map(escapeCell).join(",")}
+`);
+    for (const row of rows) {
+      _fs.writeSync.call(void 0, 
+        fd,
+        `${columns.map((column) => escapeCell(row[column])).join(",")}
+`
+      );
+    }
+  } finally {
+    _fs.closeSync.call(void 0, 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 {};
+}
+
+
+
+
+
+
+
+exports.tryConvertToList = tryConvertToList; exports.projectRowOutput = projectRowOutput; exports.writeJsonOutputFile = writeJsonOutputFile; exports.writeCsvOutputFile = writeCsvOutputFile; exports.extractSummaryFields = extractSummaryFields;

package/dist/cli/{chunk-VB6KECLU.mjs → chunk-IHG7UAHD.mjs}

@@ -1,6 +1,9 @@
 import {
   shellQuote
 } from "./chunk-OVDNJAJN.mjs";
+import {
+  cloneEditStarter
+} from "./chunk-EIMG75BT.mjs";
 
 // src/cli/described.ts
 var SHAPE = "{}";
@@ -617,84 +620,66 @@ function describedJson(described, view) {
     ...hidden.length ? { hidden } : {}
   };
 }
-
-// src/cli/execution-observation.ts
-import { writeFileSync, renameSync } from "fs";
-function writeObservation(observation) {
-  const path = process.env.DEEPLINE_EXECUTION_OBSERVATION_PATH;
-  const invocationId = process.env.DEEPLINE_EXECUTION_OBSERVATION_ID;
-  if (!path || !invocationId) return;
-  const pending = `${path}.pending`;
-  writeFileSync(
-    pending,
-    JSON.stringify({
-      schema_version: 1,
-      invocation_id: invocationId,
-      ...observation
-    }),
-    { mode: 384 }
-  );
-  renameSync(pending, path);
+function buildPlayDashboardUrl(baseUrl, playName) {
+  const trimmedBase = baseUrl.replace(/\/$/, "");
+  const encodedPlayName = encodeURIComponent(playName);
+  return `${trimmedBase}/dashboard/plays/${encodedPlayName}`;
 }
-function recordApiResponse(observation) {
-  writeObservation({
-    kind: "api_response",
-    received_at_ms: observation.receivedAtMs,
-    state: observation.state,
-    http_status: observation.httpStatus
-  });
-}
-function recordPlayTermination(run) {
-  if (typeof run.id !== "string" || !["completed", "failed", "cancelled", "canceled"].includes(
-    String(run.status)
-  ) || typeof run.finishedAt !== "number" || !Number.isSafeInteger(run.finishedAt) || run.finishedAt <= 0)
-    return;
-  writeObservation({
-    kind: "play_terminal",
-    run: { id: run.id, status: run.status, finishedAt: run.finishedAt }
+function describedPlay(play) {
+  const reference = play.reference || play.name;
+  const starter = play.cloneEditStarter ?? cloneEditStarter(play);
+  const csv = play.csvInput ?? {};
+  const csvField = typeof csv.inputField === "string" ? csv.inputField : "csv";
+  const alongside = /* @__PURE__ */ new Set([
+    csvField,
+    "columns",
+    ...Array.isArray(csv.runLevelControlFields) ? csv.runLevelControlFields.map(String) : []
+  ]);
+  const declared = schemaFields(play.inputSchema).map((field) => field.name);
+  const rowNames = schemaFields(csv.rowInputSchema).map((field) => field.name);
+  const replaced = play.csvInput ? (rowNames.length > 0 ? rowNames : declared).filter(
+    (name) => declared.includes(name) && !alongside.has(name)
+  ) : [];
+  const exclusive = replaced.length ? { field: csvField, with: replaced } : void 0;
+  const headers = isRecord(csv.defaultColumns) ? csv.defaultColumns : {};
+  const rowInputs = schemaFields(csv.rowInputSchema).map((field) => {
+    const header = [headers[field.name]].flat().filter((name) => name && name !== field.name).join(" or ");
+    return header ? {
+      ...field,
+      description: [field.description, `CSV header: ${header}`].filter(Boolean).join(" - ")
+    } : field;
   });
-}
-
-// src/cli/describe-options.ts
-function addDescribeOptions(command, options = {}) {
-  command.option(
-    "--prebuilt",
-    "Show the Deepline tool or play, not a play your workspace created under the same name"
-  ).option("--tool", "Same as --prebuilt").option(
-    "--verbose",
-    "Show secondary fields, and fill in every input and read every output in the examples"
-  ).option(
-    "--cli-example",
-    "Show only the CLI example, and explain how it takes inputs and returns outputs"
-  ).option(
-    "--play-example",
-    "Show only the in-play example, and explain how it takes inputs and returns outputs"
-  ).option("--no-example", "Hide the run examples").option(
-    "--full-schema",
-    `Print every field: a long schema unfolded (over ${SCHEMA_LINE_LIMIT} lines), list rows, and a tool's raw response`
-  ).option(
-    "--fields <names>",
-    "Show only these fields, comma-separated, plus every required input"
-  ).option(
-    "--feature <name[=value]>",
-    "Describe one feature of a tool, such as a model: --feature model=openai/gpt-5.6-luna. A tool lists its features."
-  ).option(
-    "-o, --out <path>",
-    "Save the output to this file instead of printing it"
-  );
-  if (options.schemaOnly !== false) {
-    command.option(
-      "--schema-only",
-      "Print only the schema, with every field, and nothing else"
-    );
-  }
-  if (options.json !== false) {
-    command.option(
-      "--json",
-      "Print JSON instead of text; with --schema-only, only the input and output JSON Schemas"
-    );
-  }
-  return command;
+  const rowOutput = play.rowOutputSchema ?? {};
+  const added = isRecord(rowOutput.addedColumns) ? rowOutput.addedColumns : {};
+  const rowOutputs = schemaFields(
+    Object.keys(added).length ? { properties: added } : rowOutput
+  ).map((field) => ({ ...field, required: true }));
+  return {
+    kind: play.ownerType === "deepline" ? "prebuilt_play" : "custom_play",
+    id: reference,
+    ...play.displayName && play.displayName !== play.name ? { displayName: play.displayName } : {},
+    ...play.description ? { description: play.description } : {},
+    ...play.observedCost ? { cost: play.observedCost.displayText } : {},
+    guidance: [],
+    inputs: schemaFields(play.inputSchema),
+    outputs: schemaFields(play.outputSchema),
+    ...rowInputs.length ? { rowInputs } : {},
+    ...typeof csv.inputField === "string" ? { csvInput: csv.inputField } : {},
+    ...rowOutputs.length ? {
+      rowOutputs,
+      rowOutputsAddToSource: Object.keys(added).length > 0 || rowOutput.preservesSourceColumns === true
+    } : {},
+    runner: {
+      via: "play",
+      reference,
+      // A CSV play's run command is built by the server around its columns.
+      ...play.csvInput ? { cli: play.runCommand } : {}
+    },
+    ...starter ? { source: starter.command } : {},
+    ...exclusive ? { exclusive } : {},
+    // A prebuilt's cost is what its recent runs were charged; there is no rate.
+    ...play.observedCost?.displayText ? { cost: play.observedCost.displayText } : {}
+  };
 }
 
 export {
@@ -708,7 +693,6 @@ export {
   describedLines,
   topLevelField,
   describedJson,
-  recordApiResponse,
-  recordPlayTermination,
-  addDescribeOptions
+  buildPlayDashboardUrl,
+  describedPlay
 };

package/dist/cli/{chunk-TO2MWPGR.js → chunk-IZ74ABSX.js}

@@ -49,7 +49,7 @@ var SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: "0.3.395",
+  version: "0.3.397",
   updateSummary: "Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.",
   packageCapabilities: {
     updatePreferences: 1,

package/dist/cli/{chunk-G4IWGRMK.mjs → chunk-J7ABTQQ7.mjs}

@@ -17,15 +17,17 @@ import {
 import {
   describePlayDetail,
   describePlayListItem
-} from "./chunk-5VCZ3WRH.mjs";
+} from "./chunk-EIMG75BT.mjs";
 import {
   COORDINATOR_INTERNAL_TOKEN_HEADER,
-  CustomerDbQueryOutcomeUnknownError,
   HttpClient,
   RETAINED_PIPELINE_RECEIVERS_HEADER,
   RUNTIME_ENVIRONMENT_TOKEN_HEADER,
   resolveConfig
-} from "./chunk-6D7A2FSL.mjs";
+} from "./chunk-2LDADJNO.mjs";
+import {
+  CustomerDbQueryOutcomeUnknownError
+} from "./chunk-YHPYUZZX.mjs";
 import {
   DeeplineError,
   TOOL_EXECUTION_ERROR_SCHEMA_HEADER,