deepline 0.3.294 → 0.3.295

package/dist/cli/chunk-WJYPBHTE.js

@@ -0,0 +1,148 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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; } var _class;// src/cli/progress.ts
+var _worker_threads = require('worker_threads');
+var CliProgress = (_class = class {
+  constructor(enabled) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);
+    this.enabled = enabled;
+  }
+  __init() {this.lastMessage = null}
+  __init2() {this.interactive = Boolean(process.stderr.isTTY)}
+  __init3() {this.grey = "\x1B[90m"}
+  __init4() {this.cyan = "\x1B[36m"}
+  __init5() {this.dim = "\x1B[2m"}
+  __init6() {this.reset = "\x1B[0m"}
+  __init7() {this.worker = null}
+  phase(message) {
+    if (!this.enabled || this.lastMessage === message) {
+      return;
+    }
+    if (this.interactive && this.lastMessage) {
+      this.settle("\u2713");
+    }
+    this.lastMessage = message;
+    if (!this.interactive) {
+      process.stderr.write(`${message}
+`);
+      return;
+    }
+    this.ensureWorker();
+    _optionalChain([this, 'access', _ => _.worker, 'optionalAccess', _2 => _2.postMessage, 'call', _3 => _3({ type: "phase", message })]);
+  }
+  complete() {
+    this.settle("\u2713");
+  }
+  fail() {
+    this.settle("\u2717");
+  }
+  writeLogLine(line) {
+    if (!this.enabled) {
+      process.stderr.write(`${line}
+`);
+      return;
+    }
+    const message = this.interactive ? `${this.cyan}[logs]${this.reset} ${this.dim}${line}${this.reset}` : `[logs] ${line}`;
+    if (!this.interactive) {
+      process.stderr.write(`${message}
+`);
+      return;
+    }
+    const activeMessage = this.lastMessage;
+    _optionalChain([this, 'access', _4 => _4.worker, 'optionalAccess', _5 => _5.terminate, 'call', _6 => _6(), 'access', _7 => _7.catch, 'call', _8 => _8(() => void 0)]);
+    this.worker = null;
+    process.stderr.write(`\r\x1B[2K${message}
+`);
+    if (activeMessage) {
+      this.startWorker().postMessage({ type: "phase", message: activeMessage });
+    }
+  }
+  writeLine(line, stream = process.stderr) {
+    if (!this.enabled || !this.interactive) {
+      stream.write(`${line}
+`);
+      return;
+    }
+    const activeMessage = this.lastMessage;
+    _optionalChain([this, 'access', _9 => _9.worker, 'optionalAccess', _10 => _10.terminate, 'call', _11 => _11(), 'access', _12 => _12.catch, 'call', _13 => _13(() => void 0)]);
+    this.worker = null;
+    stream.write(`\r\x1B[2K${line}
+`);
+    if (activeMessage) {
+      this.startWorker().postMessage({ type: "phase", message: activeMessage });
+    }
+  }
+  settle(mark) {
+    if (!this.enabled || !this.lastMessage) {
+      return;
+    }
+    if (this.interactive) {
+      _optionalChain([this, 'access', _14 => _14.worker, 'optionalAccess', _15 => _15.terminate, 'call', _16 => _16(), 'access', _17 => _17.catch, 'call', _18 => _18(() => void 0)]);
+      this.worker = null;
+      process.stderr.write(
+        `\r\x1B[2K${this.grey}${mark} ${this.lastMessage}${this.reset}
+`
+      );
+    }
+    this.lastMessage = null;
+  }
+  ensureWorker() {
+    this.startWorker();
+  }
+  startWorker() {
+    if (this.worker) {
+      return this.worker;
+    }
+    this.worker = new (0, _worker_threads.Worker)(
+      `
+        const { parentPort } = require('node:worker_threads');
+        const { writeSync } = require('node:fs');
+        const frames = ['\u2014', '\\\\', '|', '/'];
+        const grey = '\\x1b[90m';
+        const reset = '\\x1b[0m';
+        let message = '';
+        let frameIndex = 0;
+        let timer = null;
+        function render() {
+          if (!message) return;
+          const frame = frames[frameIndex % frames.length] || '\u2014';
+          frameIndex += 1;
+          writeSync(2, '\\r\\x1b[2K' + grey + frame + ' ' + message + reset);
+        }
+        parentPort.on('message', (event) => {
+          if (event.type === 'phase') {
+            message = String(event.message || '');
+            frameIndex = 0;
+            render();
+            if (!timer) {
+              timer = setInterval(render, 120);
+              timer.unref && timer.unref();
+            }
+          }
+          if (event.type === 'stop') {
+            if (timer) clearInterval(timer);
+            timer = null;
+            writeSync(2, '\\r\\x1b[2K');
+          }
+        });
+      `,
+      { eval: true }
+    );
+    this.worker.unref();
+    return this.worker;
+  }
+}, _class);
+var activeProgress = null;
+function setActiveCliProgress(progress) {
+  activeProgress = progress;
+}
+function getActiveCliProgress() {
+  return activeProgress;
+}
+function createCliProgress(enabled) {
+  const progress = new CliProgress(enabled);
+  setActiveCliProgress(progress);
+  return progress;
+}
+
+
+
+
+exports.getActiveCliProgress = getActiveCliProgress; exports.createCliProgress = createCliProgress;

package/dist/cli/chunk-WOHBA5PV.js

@@ -0,0 +1,354 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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; }// ../integration-contracts/monitor-input-contract.ts
+var _handlebars = require('handlebars'); var _handlebars2 = _interopRequireDefault(_handlebars);
+function authoredMonitorFieldPath(path, field) {
+  const batch = /^monitors\.(\d+)$/.exec(path);
+  return `${batch ? `monitors[${batch[1]}]` : path}.${field}`;
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function json(value, path, issues) {
+  if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((child, index) => json(child, `${path}.${index}`, issues));
+    return;
+  }
+  const object = record(value);
+  if (!object) {
+    issues.push({
+      severity: "error",
+      code: "invalid_monitor_json_value",
+      path,
+      message: "Monitor values must be JSON values."
+    });
+    return;
+  }
+  for (const [key, child] of Object.entries(object)) {
+    json(child, `${path}.${key}`, issues);
+  }
+}
+function monitorSpec(value, path, issues) {
+  const input = record(value);
+  if (!input) {
+    issues.push({
+      severity: "error",
+      code: "invalid_monitor_spec",
+      path,
+      message: "A monitor must be a JSON object."
+    });
+    return null;
+  }
+  const allowed = /* @__PURE__ */ new Set(["key", "tool", "name", "payload"]);
+  for (const key2 of Object.keys(input)) {
+    if (!allowed.has(key2)) {
+      if (key2 === "controls") {
+        issues.push({
+          severity: "error",
+          code: "CONTROLS_NOT_SUPPORTED",
+          path: authoredMonitorFieldPath(path, "controls"),
+          message: "Operational controls are managed by Deepline and cannot be authored in Batch or Fleet JSON.",
+          suggestion: "Remove controls. Bind downstream automation in a Play with sqlListeners."
+        });
+        continue;
+      }
+      if (key2 === "play") {
+        issues.push({
+          severity: "error",
+          code: "PLAY_BINDING_NOT_IN_MONITOR_SPEC",
+          path: authoredMonitorFieldPath(path, "play"),
+          message: "A monitor does not own Play bindings.",
+          suggestion: "Declare sqlListeners in the Play, or run: deepline plays bootstrap monitor-triggered --out on-event.play.ts"
+        });
+        continue;
+      }
+      issues.push({
+        severity: "error",
+        code: "unknown_monitor_field",
+        path: `${path}.${key2}`,
+        message: `Monitor definitions do not accept '${key2}'.`
+      });
+    }
+  }
+  const key = typeof input.key === "string" ? input.key.trim() : "";
+  const tool = typeof input.tool === "string" ? input.tool.trim() : "";
+  const name = input.name === void 0 ? void 0 : typeof input.name === "string" && input.name.trim() ? input.name.trim() : null;
+  const payload = record(input.payload);
+  if (!key) {
+    issues.push({
+      severity: "error",
+      code: "invalid_monitor_key",
+      path: `${path}.key`,
+      message: "Monitor key must be a non-empty string."
+    });
+  }
+  if (!tool) {
+    issues.push({
+      severity: "error",
+      code: "invalid_monitor_tool",
+      path: `${path}.tool`,
+      message: "Monitor tool must be a non-empty literal string."
+    });
+  }
+  if (name === null) {
+    issues.push({
+      severity: "error",
+      code: "invalid_monitor_name",
+      path: `${path}.name`,
+      message: "Monitor name must be a non-empty string when supplied."
+    });
+  }
+  if (!payload) {
+    issues.push({
+      severity: "error",
+      code: "invalid_monitor_payload",
+      path: `${path}.payload`,
+      message: "Monitor payload must be an object."
+    });
+  } else {
+    json(payload, `${path}.payload`, issues);
+  }
+  if (!key || !tool || !payload || name === null) {
+    return null;
+  }
+  return {
+    key,
+    tool,
+    ...name ? { name } : {},
+    payload
+  };
+}
+function issueOrder(left, right) {
+  return left.path.localeCompare(right.path) || left.severity.localeCompare(right.severity) || left.code.localeCompare(right.code);
+}
+function lintMonitorBatchInput(value) {
+  const issues = [];
+  const versionlessEnvelope = !Array.isArray(value) && (() => {
+    const candidate = record(value);
+    return candidate !== null && Object.keys(candidate).length === 1 && Object.prototype.hasOwnProperty.call(candidate, "monitors");
+  })();
+  const legacy = Array.isArray(value) || versionlessEnvelope;
+  const input = legacy ? null : record(value);
+  let monitors = Array.isArray(value) ? value : versionlessEnvelope ? (() => {
+    const candidate = _optionalChain([record, 'call', _ => _(value), 'optionalAccess', _2 => _2.monitors]);
+    return Array.isArray(candidate) ? candidate : null;
+  })() : null;
+  if (Array.isArray(value)) {
+    issues.push({
+      severity: "warning",
+      code: "deprecated_batch_array",
+      path: "",
+      message: "Bare monitor arrays are supported for compatibility.",
+      suggestion: 'Wrap the list in {"version":1,"kind":"batch","monitors":[...]}.'
+    });
+  } else if (versionlessEnvelope) {
+    issues.push({
+      severity: "warning",
+      code: "deprecated_batch_missing_envelope_fields",
+      path: "",
+      message: "Versionless monitor envelopes are supported for compatibility.",
+      suggestion: 'Add "version": 1 and "kind": "batch".'
+    });
+    if (!monitors) {
+      issues.push({
+        severity: "error",
+        code: "invalid_batch_monitors",
+        path: "monitors",
+        message: "Batch monitors must be an array."
+      });
+    }
+  } else if (!input) {
+    issues.push({
+      severity: "error",
+      code: "invalid_batch",
+      path: "",
+      message: "Batch input must be an object or a legacy array."
+    });
+  } else {
+    for (const key of Object.keys(input)) {
+      if (!["version", "kind", "monitors"].includes(key)) {
+        issues.push({
+          severity: "error",
+          code: key === "source" || key === "monitor" ? "batch_fleet_shape_mixup" : "unknown_batch_field",
+          path: key,
+          message: `Batch input does not accept '${key}'.`
+        });
+      }
+    }
+    if (input.version !== 1) {
+      issues.push({
+        severity: "error",
+        code: "unsupported_batch_version",
+        path: "version",
+        message: "Batch input version must be 1."
+      });
+    }
+    if (input.kind !== "batch") {
+      issues.push({
+        severity: "error",
+        code: "invalid_batch_kind",
+        path: "kind",
+        message: 'Batch input kind must be "batch".'
+      });
+    }
+    monitors = Array.isArray(input.monitors) ? input.monitors : null;
+    if (!monitors) {
+      issues.push({
+        severity: "error",
+        code: "invalid_batch_monitors",
+        path: "monitors",
+        message: "Batch monitors must be an array."
+      });
+    }
+  }
+  if (!monitors || monitors.length === 0) {
+    if (_optionalChain([monitors, 'optionalAccess', _3 => _3.length]) === 0) {
+      issues.push({
+        severity: "error",
+        code: "empty_batch",
+        path: "monitors",
+        message: "A Batch needs at least one monitor."
+      });
+    }
+    return { issues: issues.sort(issueOrder) };
+  }
+  const normalized = monitors.map(
+    (item, index) => monitorSpec(item, `monitors.${index}`, issues)
+  );
+  const seen = /* @__PURE__ */ new Map();
+  normalized.forEach((item, index) => {
+    if (!item) return;
+    const first = seen.get(item.key);
+    if (first !== void 0) {
+      for (const position of [first, index]) {
+        issues.push({
+          severity: "error",
+          code: "duplicate_monitor_key",
+          path: `monitors.${position}.key`,
+          message: `Duplicate monitor key '${item.key}'.`
+        });
+      }
+    } else {
+      seen.set(item.key, index);
+    }
+  });
+  const ordered = issues.sort(issueOrder);
+  return ordered.some((issue) => issue.severity === "error") ? { issues: ordered } : {
+    normalized: {
+      version: 1,
+      kind: "batch",
+      monitors: normalized
+    },
+    issues: ordered
+  };
+}
+function validateHandlebars(value, path, issues) {
+  if (!value.includes("{{")) return;
+  try {
+    _handlebars2.default.parse(value);
+  } catch (error) {
+    issues.push({
+      severity: "error",
+      code: "invalid_handlebars_template",
+      path,
+      message: error instanceof Error ? error.message : "Invalid Handlebars template."
+    });
+    return;
+  }
+  const expressions = _nullishCoalesce(value.match(/{{[\s\S]*?}}/g), () => ( []));
+  if (expressions.some(
+    (expression) => !/^{{\s*[A-Za-z_][A-Za-z0-9_]*\s*}}$/.test(expression)
+  )) {
+    issues.push({
+      severity: "error",
+      code: "unsupported_handlebars_expression",
+      path,
+      message: "Fleet templates allow only direct source-row fields such as {{domain}}; helpers, blocks, partials, paths, and prototype access are disabled."
+    });
+  }
+}
+function walkTemplates(value, path, issues) {
+  if (typeof value === "string") return validateHandlebars(value, path, issues);
+  if (Array.isArray(value)) {
+    value.forEach(
+      (item, index) => walkTemplates(item, `${path}.${index}`, issues)
+    );
+    return;
+  }
+  const input = record(value);
+  if (!input) return;
+  for (const [key, child] of Object.entries(input)) {
+    walkTemplates(child, `${path}.${key}`, issues);
+  }
+}
+function lintMonitorSpecTemplate(value, path = "monitor") {
+  const issues = [];
+  const normalized = monitorSpec(value, path, issues);
+  const input = record(value);
+  if (input && typeof input.tool === "string" && input.tool.includes("{{")) {
+    issues.push({
+      severity: "error",
+      code: "templated_monitor_tool",
+      path: `${path}.tool`,
+      message: "Fleet monitor tool must be literal; only key, name, and payload may be templated."
+    });
+  }
+  if (input) {
+    for (const field of ["key", "name", "payload"]) {
+      if (input[field] !== void 0)
+        walkTemplates(input[field], `${path}.${field}`, issues);
+    }
+  }
+  const ordered = issues.sort(issueOrder);
+  return ordered.some((issue) => issue.severity === "error") ? { issues: ordered } : { normalized, issues: ordered };
+}
+function renderValue(value, row) {
+  if (typeof value === "string" && value.includes("{{")) {
+    const context = Object.assign(/* @__PURE__ */ Object.create(null), row);
+    return _handlebars2.default.compile(value, {
+      noEscape: true,
+      strict: true,
+      knownHelpersOnly: true,
+      preventIndent: true
+    })(context, {
+      allowProtoMethodsByDefault: false,
+      allowProtoPropertiesByDefault: false,
+      helpers: /* @__PURE__ */ Object.create(null),
+      partials: /* @__PURE__ */ Object.create(null)
+    });
+  }
+  if (Array.isArray(value)) return value.map((item) => renderValue(item, row));
+  const input = record(value);
+  if (!input) return value;
+  return Object.fromEntries(
+    Object.entries(input).map(([key, item]) => [key, renderValue(item, row)])
+  );
+}
+function renderMonitorSpecTemplate(template, row) {
+  const lint = lintMonitorSpecTemplate(template);
+  if (!lint.normalized) return { issues: lint.issues };
+  try {
+    const rendered = renderValue(lint.normalized, row);
+    const issues = [];
+    const spec = monitorSpec(rendered, "monitor", issues);
+    return spec ? { spec, issues: issues.sort(issueOrder) } : { issues: issues.sort(issueOrder) };
+  } catch (error) {
+    return {
+      issues: [
+        {
+          severity: "error",
+          code: "monitor_template_render_failed",
+          path: "monitor",
+          message: error instanceof Error ? error.message : "Fleet template rendering failed."
+        }
+      ]
+    };
+  }
+}
+
+
+
+
+
+exports.lintMonitorBatchInput = lintMonitorBatchInput; exports.lintMonitorSpecTemplate = lintMonitorSpecTemplate; exports.renderMonitorSpecTemplate = renderMonitorSpecTemplate;

package/dist/cli/chunk-WQICC2B3.js

@@ -0,0 +1,190 @@
+"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; }
+
+var _chunk2S5Y3TZPjs = require('./chunk-2S5Y3TZP.js');
+
+
+var _chunkF35VOIQLjs = require('./chunk-F35VOIQL.js');
+
+
+
+var _chunkXRK2TZT5js = require('./chunk-XRK2TZT5.js');
+
+// src/cli/search-ref.ts
+var _fs = require('fs');
+var _path = require('path');
+var SEARCH_REF_TTL_MS = 15 * 6e4;
+function lastSearchPath() {
+  return _path.join.call(void 0, _chunkXRK2TZT5js.sdkCliStateDirPath.call(void 0, _chunkXRK2TZT5js.resolveConfig.call(void 0, ).baseUrl), "last-search.json");
+}
+function rememberSearchRef(searchRef) {
+  try {
+    _fs.mkdirSync.call(void 0, _path.dirname.call(void 0, lastSearchPath()), { recursive: true });
+    _fs.writeFileSync.call(void 0, 
+      lastSearchPath(),
+      JSON.stringify({ searchRef, at: Date.now() }),
+      { mode: 384 }
+    );
+  } catch (e) {
+  }
+}
+function recentSearchRef() {
+  try {
+    const saved = JSON.parse(_fs.readFileSync.call(void 0, lastSearchPath(), "utf8"));
+    return typeof saved.searchRef === "string" && typeof saved.at === "number" && Date.now() - saved.at < SEARCH_REF_TTL_MS ? saved.searchRef : void 0;
+  } catch (e2) {
+    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 = (_nullishCoalesce(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 = _nullishCoalesce(_optionalChain([queryInput, 'optionalAccess', _ => _.trim, 'call', _2 => _2()]), () => ( ""));
+  const searchTerms = _nullishCoalesce(options.searchTerms, () => ( options.search_terms));
+  if (!query && !_optionalChain([options, 'access', _3 => _3.categories, 'optionalAccess', _4 => _4.trim, 'call', _5 => _5()]) && !_optionalChain([searchTerms, 'optionalAccess', _6 => _6.trim, 'call', _7 => _7()])) {
+    console.error(USAGE);
+    return 1;
+  }
+  const { search_ref: searchRef, ...result } = await new (0, _chunk2S5Y3TZPjs.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);
+  _chunkF35VOIQLjs.printCommandEnvelope.call(void 0, 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);
+  });
+}
+
+
+
+
+
+exports.recentSearchRef = recentSearchRef; exports.registerDeprecatedSearchCommand = registerDeprecatedSearchCommand; exports.registerSearchCommand = registerSearchCommand;