deepline 0.3.324 → 0.3.326

package/dist/cli/chunk-GVESPYSY.mjs

@@ -0,0 +1,234 @@
+// src/plays/local-play-execution.ts
+function importedNodes(graph) {
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const ordered = [];
+  const names = /* @__PURE__ */ new Map();
+  const visit = (node) => {
+    if (visiting.has(node.filePath))
+      throw new Error(`Recursive imported Play graph at ${node.filePath}.`);
+    if (visited.has(node.filePath)) return;
+    visiting.add(node.filePath);
+    for (const dependency of node.importedPlayDependencies) {
+      const child = graph.nodes.get(dependency.filePath);
+      if (!child)
+        throw new Error(
+          `Missing bundled Play dependency ${dependency.filePath}.`
+        );
+      visit(child);
+    }
+    visiting.delete(node.filePath);
+    visited.add(node.filePath);
+    if (node === graph.root) return;
+    if (!node.playName)
+      throw new Error(
+        `Imported Play ${node.filePath} must export definePlay(...).`
+      );
+    const existing = names.get(node.playName);
+    if (existing !== void 0 && existing !== node.filePath)
+      throw new Error(
+        `Imported Play name ${node.playName} belongs to more than one source file.`
+      );
+    names.set(node.playName, node.filePath);
+    ordered.push(node);
+  };
+  visit(graph.root);
+  return ordered;
+}
+function planLocalPlayExecution(graph, input = {}) {
+  const imports = importedNodes(graph).map((node) => ({
+    name: node.playName,
+    artifactHash: node.artifact.artifactHash,
+    graphHash: node.artifact.graphHash
+  }));
+  return {
+    command: "plays run",
+    root: {
+      name: graph.root.playName,
+      artifactHash: graph.root.artifact.artifactHash,
+      publication: "unpublished"
+    },
+    importedPlays: imports.map((node) => ({
+      ...node,
+      publication: "pinned"
+    })),
+    effects: {
+      cloudMutations: imports.length ? [
+        "store_imported_execution_artifacts",
+        "stage_files_if_present",
+        "register_unpublished_root_revision",
+        "start_run"
+      ] : [
+        "stage_files_if_present",
+        "register_unpublished_root_revision",
+        "start_run"
+      ],
+      localWrites: input.runIdFile ? ["bundle_cache", "run_identity_file"] : ["bundle_cache"],
+      creditSpending: "tool_calls_may_spend",
+      recovery: "inspect_or_resume_original_run_id"
+    }
+  };
+}
+async function pinLocalPlayImports(client, graph) {
+  const imports = importedNodes(graph);
+  if (imports.length === 0) return graph;
+  for (const node of [...imports, graph.root]) {
+    if (!node.compilerManifest)
+      throw new Error(`Missing compiler manifest for ${node.filePath}.`);
+  }
+  const nodes = new Map(graph.nodes);
+  const stored = /* @__PURE__ */ new Map();
+  const withPins = (node) => {
+    const closure = /* @__PURE__ */ new Map();
+    for (const dependency of node.importedPlayDependencies) {
+      const child = nodes.get(dependency.filePath);
+      const pointer = stored.get(dependency.filePath);
+      if (!pointer)
+        throw new Error(`Imported Play ${dependency.filePath} was not stored.`);
+      for (const [name, pin] of Object.entries(
+        child.artifact.importedPlayArtifacts ?? {}
+      ))
+        closure.set(name, pin);
+      closure.set(child.playName, pointer);
+    }
+    return {
+      ...node,
+      artifact: {
+        ...node.artifact,
+        ...closure.size ? { importedPlayArtifacts: Object.fromEntries(closure) } : {}
+      }
+    };
+  };
+  for (const original of imports) {
+    const node = withPins(original);
+    const result = await client.registerPlayArtifact({
+      name: node.playName,
+      sourceCode: node.sourceCode,
+      sourceFiles: node.sourceFiles,
+      description: node.playDescription ?? void 0,
+      artifact: node.artifact,
+      compilerManifest: node.compilerManifest,
+      publish: false,
+      artifactOnly: true
+    });
+    if (typeof result.artifactStorageKey !== "string" || !result.artifactStorageKey.trim())
+      throw new Error(
+        `No immutable artifact identity was returned for ${node.playName}.`
+      );
+    stored.set(node.filePath, {
+      artifactStorageKey: result.artifactStorageKey,
+      artifactHash: node.artifact.artifactHash,
+      graphHash: node.artifact.graphHash
+    });
+    nodes.set(node.filePath, node);
+  }
+  const root = withPins(graph.root);
+  nodes.set(root.filePath, root);
+  return { root, nodes };
+}
+
+// ../plays/bootstrap-routes.ts
+var DEEPLINE_TOOL_CATEGORIES = [
+  "company_search",
+  "people_search",
+  "people_enrich",
+  "email_finder",
+  "email_verify",
+  "phone_finder",
+  "phone_verify",
+  "identity_resolution",
+  "reverse_lookup",
+  "enrichment",
+  "batch",
+  "premium",
+  "free"
+];
+var PLAY_BOOTSTRAP_TEMPLATES = [
+  "people-list",
+  "company-list",
+  "people-email",
+  "people-phone",
+  "company-people",
+  "company-people-email",
+  "company-people-phone"
+];
+var PLAY_BOOTSTRAP_SOURCE_KINDS = [
+  "csv",
+  "play",
+  "provider",
+  "providers"
+];
+var PLAY_BOOTSTRAP_STAGE_KINDS = [
+  "play",
+  "provider",
+  "providers"
+];
+var PLAY_BOOTSTRAP_FINDER_KINDS = [
+  "email_finder",
+  "phone_finder"
+];
+var PLAY_BOOTSTRAP_COMPANY_PROVIDER_CATEGORY = "company_search";
+var PLAY_BOOTSTRAP_PEOPLE_PROVIDER_CATEGORY = "people_search";
+var PLAY_BOOTSTRAP_PROVIDER_CATEGORY_BY_FINDER = {
+  email_finder: "email_finder",
+  phone_finder: "phone_finder"
+};
+var PLAY_BOOTSTRAP_OUTPUT_FIELD_BY_FINDER = {
+  email_finder: "email",
+  phone_finder: "phone"
+};
+var PLAY_BOOTSTRAP_CONTACT_FIELDS = [
+  "first_name",
+  "last_name",
+  "domain",
+  "company_name",
+  "linkedin_url",
+  "title",
+  "email",
+  "phone"
+];
+var PLAY_BOOTSTRAP_COMPANY_FIELDS = [
+  "domain",
+  "company_domain",
+  "company_name",
+  "linkedin_url",
+  "website"
+];
+function isPlayBootstrapFinderKind(value) {
+  return PLAY_BOOTSTRAP_FINDER_KINDS.includes(value);
+}
+function isPlayBootstrapTemplate(value) {
+  return PLAY_BOOTSTRAP_TEMPLATES.includes(value);
+}
+function formatPlayBootstrapFinderKinds() {
+  return PLAY_BOOTSTRAP_FINDER_KINDS.join("|");
+}
+function formatPlayBootstrapTemplates() {
+  return PLAY_BOOTSTRAP_TEMPLATES.join("|");
+}
+function formatPlayBootstrapFinderKindsForSentence() {
+  const allButLast = PLAY_BOOTSTRAP_FINDER_KINDS.slice(0, -1);
+  const last = PLAY_BOOTSTRAP_FINDER_KINDS.at(-1);
+  return `${allButLast.join(", ")} or ${last}`;
+}
+
+export {
+  planLocalPlayExecution,
+  pinLocalPlayImports,
+  DEEPLINE_TOOL_CATEGORIES,
+  PLAY_BOOTSTRAP_TEMPLATES,
+  PLAY_BOOTSTRAP_SOURCE_KINDS,
+  PLAY_BOOTSTRAP_STAGE_KINDS,
+  PLAY_BOOTSTRAP_FINDER_KINDS,
+  PLAY_BOOTSTRAP_COMPANY_PROVIDER_CATEGORY,
+  PLAY_BOOTSTRAP_PEOPLE_PROVIDER_CATEGORY,
+  PLAY_BOOTSTRAP_PROVIDER_CATEGORY_BY_FINDER,
+  PLAY_BOOTSTRAP_OUTPUT_FIELD_BY_FINDER,
+  PLAY_BOOTSTRAP_CONTACT_FIELDS,
+  PLAY_BOOTSTRAP_COMPANY_FIELDS,
+  isPlayBootstrapFinderKind,
+  isPlayBootstrapTemplate,
+  formatPlayBootstrapFinderKinds,
+  formatPlayBootstrapTemplates,
+  formatPlayBootstrapFinderKindsForSentence
+};