deepline 0.3.294 → 0.3.296

package/dist/cli/chunk-A7427JJH.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 _chunk2C3AVPTYjs = require('./chunk-2C3AVPTY.js');
+
+
+var _chunk7D6QG5KFjs = require('./chunk-7D6QG5KF.js');
+
+
+
+var _chunk6HPEDBSJjs = require('./chunk-6HPEDBSJ.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, _chunk6HPEDBSJjs.sdkCliStateDirPath.call(void 0, _chunk6HPEDBSJjs.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, _chunk2C3AVPTYjs.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);
+  _chunk7D6QG5KFjs.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;