deepline 0.1.12 → 0.1.19

package/dist/repo/sdk/src/plays/bundle-play-file.ts

@@ -43,7 +43,7 @@ export {
   extractDefinedPlayName,
 } from '../../../shared_libs/plays/bundling/index.js';
 
-const PLAY_BUNDLE_CACHE_VERSION = 24;
+const PLAY_BUNDLE_CACHE_VERSION = 26;
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 const SDK_PACKAGE_ROOT = resolve(MODULE_DIR, '..', '..');
 const SOURCE_REPO_ROOT = resolve(SDK_PACKAGE_ROOT, '..');
@@ -66,13 +66,28 @@ const SDK_SOURCE_ROOT = HAS_SOURCE_BUNDLING_SOURCES
   : resolve(SDK_PACKAGE_ROOT, 'src');
 const SDK_PACKAGE_JSON = resolve(SDK_PACKAGE_ROOT, 'package.json');
 const SDK_ENTRY_FILE = resolve(SDK_SOURCE_ROOT, 'index.ts');
-const SDK_TYPES_ENTRY_FILE = resolve(SDK_PACKAGE_ROOT, 'dist', 'index.d.ts');
+const SDK_TYPES_ENTRY_FILE = HAS_SOURCE_BUNDLING_SOURCES
+  ? SDK_ENTRY_FILE
+  : resolve(SDK_PACKAGE_ROOT, 'dist', 'index.d.ts');
 const SDK_WORKERS_ENTRY_FILE = resolve(SDK_SOURCE_ROOT, 'worker-play-entry.ts');
 const WORKERS_HARNESS_ENTRY_FILE = resolve(PROJECT_ROOT, 'apps', 'play-runner-workers', 'src', 'entry.ts');
 const WORKERS_HARNESS_FILES_DIR = resolve(PROJECT_ROOT, 'apps', 'play-runner-workers', 'src');
-
 let hasWarnedAboutNonDevelopmentBundling = false;
 
+/**
+ * SDK/local bundling deliberately stays tool-metadata agnostic.
+ *
+ * The SDK's job is to turn a local play file into a portable artifact using
+ * only SDK/runtime sources. It must work for installed packages, source
+ * checkouts, CI smoke jobs, and clean worktrees without app-generated files
+ * such as `src/lib/generated/tool-typecheck-catalog.jsonl`.
+ *
+ * Tool-aware validation belongs to the Deepline API after upload:
+ * `compilePlayManifest` / server preflight runs the cloud typechecker inside
+ * the app deployment, where the generated catalog is a normal build artifact.
+ * Do not import `src/lib/plays/cloud-tool-typecheck` or any generated app
+ * catalog from this SDK adapter.
+ */
 function warnAboutNonDevelopmentBundling(filePath: string): void {
   if (hasWarnedAboutNonDevelopmentBundling) {
     return;
@@ -109,11 +124,10 @@ export function createSdkPlayBundlingAdapter(): PlayBundlingAdapter {
     sdkSourceRoot: SDK_SOURCE_ROOT,
     sdkPackageJson: SDK_PACKAGE_JSON,
     sdkEntryFile: SDK_ENTRY_FILE,
-    sdkTypesEntryFile: HAS_SOURCE_BUNDLING_SOURCES
-      ? SDK_ENTRY_FILE
-      : existsSync(SDK_TYPES_ENTRY_FILE)
-        ? SDK_TYPES_ENTRY_FILE
-        : SDK_ENTRY_FILE,
+    sdkTypesEntryFile:
+      HAS_SOURCE_BUNDLING_SOURCES || !existsSync(SDK_TYPES_ENTRY_FILE)
+        ? SDK_ENTRY_FILE
+        : SDK_TYPES_ENTRY_FILE,
     sdkWorkersEntryFile: SDK_WORKERS_ENTRY_FILE,
     workersHarnessEntryFile: WORKERS_HARNESS_ENTRY_FILE,
     workersHarnessFilesDir: WORKERS_HARNESS_FILES_DIR,

package/dist/repo/sdk/src/plays/local-file-discovery.ts

@@ -1,7 +1,6 @@
 import { createHash } from 'node:crypto';
 import { readFile, stat } from 'node:fs/promises';
 import { basename, dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
-import ts from 'typescript';
 
 export interface PlayLocalFileReference {
   sourceFragment: string;
@@ -48,126 +47,198 @@ function contentTypeForFile(filePath: string): string {
   return 'application/octet-stream';
 }
 
-function isCtxCsvCall(node: ts.CallExpression): boolean {
-  if (!ts.isPropertyAccessExpression(node.expression)) {
-    return false;
-  }
-  const target = node.expression.expression;
-  return (
-    ts.isIdentifier(target) &&
-    (target.text === 'ctx' || target.text.endsWith('Ctx')) &&
-    node.expression.name.text === 'csv'
-  );
+function stripCommentsToSpaces(source: string): string {
+  return source
+    .replace(/\/\*[\s\S]*?\*\//g, (match) => match.replace(/[^\n]/g, ' '))
+    .replace(/(^|[^:])\/\/.*$/gm, (match, prefix: string) =>
+      prefix + ' '.repeat(Math.max(0, match.length - prefix.length)),
+    );
 }
 
-function extractSourceFragment(source: string, node: ts.Node): string {
-  return source.slice(node.getStart(), node.getEnd()).trim();
+function unquoteStringLiteral(literal: string): string | null {
+  const trimmed = literal.trim();
+  const quote = trimmed[0];
+  if ((quote !== '"' && quote !== "'") || trimmed[trimmed.length - 1] !== quote) {
+    return null;
+  }
+  try {
+    return JSON.parse(quote === '"' ? trimmed : `"${trimmed.slice(1, -1).replace(/"/g, '\\"')}"`);
+  } catch {
+    return trimmed.slice(1, -1);
+  }
 }
 
-function referencesInputIdentifier(node: ts.Node): boolean {
-  if (ts.isIdentifier(node) && node.text === 'input') {
-    return true;
+function splitTopLevelPlus(expression: string): string[] | null {
+  const parts: string[] = [];
+  let start = 0;
+  let depth = 0;
+  let quote: string | null = null;
+  let escaped = false;
+
+  for (let index = 0; index < expression.length; index += 1) {
+    const char = expression[index]!;
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === '\\') {
+        escaped = true;
+      } else if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === '`') {
+      quote = char;
+      continue;
+    }
+    if (char === '(' || char === '[' || char === '{') depth += 1;
+    if (char === ')' || char === ']' || char === '}') depth -= 1;
+    if (char === '+' && depth === 0) {
+      parts.push(expression.slice(start, index));
+      start = index + 1;
+    }
   }
 
-  return node.getChildren().some((child) => referencesInputIdentifier(child));
+  if (parts.length === 0) return null;
+  parts.push(expression.slice(start));
+  return parts;
 }
 
-function isRuntimeInputExpression(node: ts.Expression): boolean {
-  if (ts.isPropertyAccessExpression(node)) {
-    return ts.isIdentifier(node.expression) && node.expression.text === 'input';
-  }
-  if (ts.isElementAccessExpression(node)) {
-    return ts.isIdentifier(node.expression) && node.expression.text === 'input';
-  }
-  if (ts.isIdentifier(node)) {
-    return node.text === 'input';
+function stripOuterParens(expression: string): string {
+  let value = expression.trim();
+  while (value.startsWith('(') && value.endsWith(')')) {
+    value = value.slice(1, -1).trim();
   }
+  return value;
+}
 
-  if (ts.isParenthesizedExpression(node)) {
-    return isRuntimeInputExpression(node.expression);
-  }
+function isRuntimeInputExpression(expression: string): boolean {
+  return /(^|[^\w$])input([^\w$]|$)/.test(expression);
+}
 
-  if (
-    ts.isBinaryExpression(node) &&
-    (node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken ||
-      node.operatorToken.kind === ts.SyntaxKind.BarBarToken)
-  ) {
-    return isRuntimeInputExpression(node.left) || isRuntimeInputExpression(node.right);
+function resolveStringExpression(expression: string, constants: ConstMap): string | null {
+  const value = stripOuterParens(expression);
+  if (/^(['"])(?:\\.|(?!\1)[\s\S])*\1$/.test(value)) {
+    return unquoteStringLiteral(value);
   }
-
-  if (ts.isConditionalExpression(node)) {
-    return (
-      isRuntimeInputExpression(node.condition) ||
-      isRuntimeInputExpression(node.whenTrue) ||
-      isRuntimeInputExpression(node.whenFalse)
-    );
+  if (/^`(?:\\.|[^`$]|\$(?!\{))*`$/.test(value)) {
+    return value.slice(1, -1);
   }
-
-  return referencesInputIdentifier(node);
-}
-
-function resolveStringExpression(node: ts.Expression, constants: ConstMap): string | null {
-  if (ts.isStringLiteralLike(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
-    return node.text;
+  if (/^[A-Za-z_$][\w$]*$/.test(value)) {
+    return constants.get(value) ?? null;
   }
-
-  if (ts.isParenthesizedExpression(node)) {
-    return resolveStringExpression(node.expression, constants);
+  const parts = splitTopLevelPlus(value);
+  if (parts) {
+    const resolved = parts.map((part) => resolveStringExpression(part, constants));
+    return resolved.every((part): part is string => part != null)
+      ? resolved.join('')
+      : null;
   }
+  return null;
+}
 
-  if (ts.isIdentifier(node)) {
-    return constants.get(node.text) ?? null;
+function collectTopLevelStringConstants(sourceCode: string): ConstMap {
+  const constants: ConstMap = new Map();
+  const source = stripCommentsToSpaces(sourceCode);
+  for (const match of source.matchAll(/(?:^|\n)\s*const\s+([A-Za-z_$][\w$]*)\s*=\s*([^;\n]+)/g)) {
+    const resolved = resolveStringExpression(match[2]!, constants);
+    if (resolved != null) {
+      constants.set(match[1]!, resolved);
+    }
   }
+  return constants;
+}
 
-  if (ts.isTemplateExpression(node)) {
-    let value = node.head.text;
-    for (const span of node.templateSpans) {
-      const resolved = resolveStringExpression(span.expression, constants);
-      if (resolved == null) {
-        return null;
+function findMatchingGenericEnd(source: string, openIndex: number): number {
+  let depth = 0;
+  let quote: string | null = null;
+  let escaped = false;
+  for (let index = openIndex; index < source.length; index += 1) {
+    const char = source[index]!;
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === '\\') {
+        escaped = true;
+      } else if (char === quote) {
+        quote = null;
       }
-      value += resolved + span.literal.text;
+      continue;
     }
-    return value;
-  }
-
-  if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.PlusToken) {
-    const left = resolveStringExpression(node.left, constants);
-    const right = resolveStringExpression(node.right, constants);
-    if (left == null || right == null) {
-      return null;
+    if (char === '"' || char === "'" || char === '`') {
+      quote = char;
+      continue;
+    }
+    if (char === '<') depth += 1;
+    if (char === '>') {
+      depth -= 1;
+      if (depth === 0) return index;
     }
-    return left + right;
   }
-
-  return null;
+  return -1;
 }
 
-function collectTopLevelStringConstants(sourceFile: ts.SourceFile): ConstMap {
-  const constants: ConstMap = new Map();
+function findCallOpenParen(source: string, afterCsvIndex: number): number {
+  let index = afterCsvIndex;
+  while (/\s/.test(source[index] ?? '')) index += 1;
+  if (source[index] === '<') {
+    const genericEnd = findMatchingGenericEnd(source, index);
+    if (genericEnd < 0) return -1;
+    index = genericEnd + 1;
+    while (/\s/.test(source[index] ?? '')) index += 1;
+  }
+  return source[index] === '(' ? index : -1;
+}
 
-  for (const statement of sourceFile.statements) {
-    if (!ts.isVariableStatement(statement)) {
+function firstCallArgument(source: string, openParen: number): { text: string; start: number; end: number } | null {
+  let depth = 0;
+  let quote: string | null = null;
+  let escaped = false;
+  const start = openParen + 1;
+
+  for (let index = start; index < source.length; index += 1) {
+    const char = source[index]!;
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === '\\') {
+        escaped = true;
+      } else if (char === quote) {
+        quote = null;
+      }
       continue;
     }
-
-    if (!(statement.declarationList.flags & ts.NodeFlags.Const)) {
+    if (char === '"' || char === "'" || char === '`') {
+      quote = char;
       continue;
     }
-
-    for (const declaration of statement.declarationList.declarations) {
-      if (!ts.isIdentifier(declaration.name) || !declaration.initializer) {
-        continue;
-      }
-
-      const resolved = resolveStringExpression(declaration.initializer, constants);
-      if (resolved != null) {
-        constants.set(declaration.name.text, resolved);
-      }
+    if (char === '(' || char === '[' || char === '{') depth += 1;
+    if (char === ')' && depth === 0) {
+      const text = source.slice(start, index).trim();
+      return text ? { text, start, end: index } : null;
     }
+    if (char === ',' && depth === 0) {
+      const text = source.slice(start, index).trim();
+      return text ? { text, start, end: index } : null;
+    }
+    if (char === ')' || char === ']' || char === '}') depth -= 1;
   }
 
-  return constants;
+  return null;
+}
+
+function localImportSpecifiers(sourceCode: string): string[] {
+  const source = stripCommentsToSpaces(sourceCode);
+  const specifiers: string[] = [];
+  for (const match of source.matchAll(
+    /\b(?:import|export)\s+(?!type\b)(?:[\s\S]*?\s+from\s*)?['"]([^'"]+)['"]/g,
+  )) {
+    if (match[1]?.startsWith('.')) specifiers.push(match[1]);
+  }
+  for (const match of source.matchAll(/\brequire\s*\(\s*(['"])(\.[^'"]*)\1\s*\)/g)) {
+    specifiers.push(match[2]!);
+  }
+  return specifiers;
 }
 
 async function fileExists(filePath: string): Promise<boolean> {
@@ -223,88 +294,64 @@ export async function discoverPackagedLocalFiles(
     visitedFiles.add(absolutePath);
 
     const sourceCode = await readFile(absolutePath, 'utf-8');
-    const sourceFile = ts.createSourceFile(
-      absolutePath,
-      sourceCode,
-      ts.ScriptTarget.Latest,
-      true,
-      ts.ScriptKind.TS,
-    );
-    const constants = collectTopLevelStringConstants(sourceFile);
+    const scanSource = stripCommentsToSpaces(sourceCode);
+    const constants = collectTopLevelStringConstants(sourceCode);
     const childVisits: Promise<void>[] = [];
 
-    const visitNode = async (node: ts.Node): Promise<void> => {
-      if (ts.isCallExpression(node) && isCtxCsvCall(node)) {
-        const argument = node.arguments[0];
-        if (!argument) {
+    for (const match of scanSource.matchAll(/\b([A-Za-z_$][\w$]*)\s*\.\s*csv\b/g)) {
+      const target = match[1]!;
+      if (target !== 'ctx' && !target.endsWith('Ctx')) {
+        continue;
+      }
+      const openParen = findCallOpenParen(scanSource, match.index! + match[0].length);
+      if (openParen < 0) {
+        continue;
+      }
+      const argument = firstCallArgument(scanSource, openParen);
+      if (!argument) {
+        unresolved.push({
+          sourceFragment: 'ctx.csv()',
+          message: 'ctx.csv() requires a file path string or input reference.',
+        });
+      } else if (!isRuntimeInputExpression(argument.text)) {
+        const resolvedPath = resolveStringExpression(argument.text, constants);
+        if (resolvedPath == null) {
           unresolved.push({
-            sourceFragment: 'ctx.csv()',
-            message: 'ctx.csv() requires a file path string or input reference.',
+            sourceFragment: sourceCode.slice(argument.start, argument.end).trim(),
+            message:
+              'Could not resolve this ctx.csv(...) path at submit time. Use a string literal, a top-level const string, or pass a runtime input like input.file.',
           });
-        } else if (!isRuntimeInputExpression(argument)) {
-          const resolvedPath = resolveStringExpression(argument, constants);
-          if (resolvedPath == null) {
+        } else {
+          const absoluteCsvPath = resolve(dirname(absolutePath), resolvedPath);
+          if (isAbsolute(resolvedPath) || !isPathInsideDirectory(absoluteCsvPath, packagingRoot)) {
             unresolved.push({
-              sourceFragment: extractSourceFragment(sourceCode, argument),
+              sourceFragment: sourceCode.slice(argument.start, argument.end).trim(),
               message:
-                'Could not resolve this ctx.csv(...) path at submit time. Use a string literal, a top-level const string, or pass a runtime input like input.file.',
-            });
-          } else {
-            const absoluteCsvPath = resolve(dirname(absolutePath), resolvedPath);
-            if (isAbsolute(resolvedPath) || !isPathInsideDirectory(absoluteCsvPath, packagingRoot)) {
-              unresolved.push({
-                sourceFragment: extractSourceFragment(sourceCode, argument),
-                message:
-                  'ctx.csv(...) packaged file paths must be relative paths inside the play directory. Pass external files at runtime with input.file instead.',
-              });
-              return;
-            }
-            const buffer = await readFile(absoluteCsvPath);
-            const stats = await stat(absoluteCsvPath);
-            files.set(absoluteCsvPath, {
-              sourceFragment: extractSourceFragment(sourceCode, argument),
-              logicalPath: resolvedPath,
-              absolutePath: absoluteCsvPath,
-              bytes: stats.size,
-              contentHash: sha256(buffer),
-              contentType: contentTypeForFile(absoluteCsvPath),
+                'ctx.csv(...) packaged file paths must be relative paths inside the play directory. Pass external files at runtime with input.file instead.',
             });
+            continue;
           }
+          const buffer = await readFile(absoluteCsvPath);
+          const stats = await stat(absoluteCsvPath);
+          files.set(absoluteCsvPath, {
+            sourceFragment: sourceCode.slice(argument.start, argument.end).trim(),
+            logicalPath: resolvedPath,
+            absolutePath: absoluteCsvPath,
+            bytes: stats.size,
+            contentHash: sha256(buffer),
+            contentType: contentTypeForFile(absoluteCsvPath),
+          });
         }
       }
+    }
 
-      if (
-        ts.isImportDeclaration(node) &&
-        !node.importClause?.isTypeOnly &&
-        ts.isStringLiteral(node.moduleSpecifier) &&
-        node.moduleSpecifier.text.startsWith('.')
-      ) {
-        childVisits.push(
-          resolveLocalImport(absolutePath, node.moduleSpecifier.text).then((resolvedImport) =>
-            visitSourceFile(resolvedImport),
-          ),
-        );
-      }
-
-      if (
-        ts.isCallExpression(node) &&
-        ts.isIdentifier(node.expression) &&
-        node.expression.text === 'require' &&
-        node.arguments.length === 1 &&
-        ts.isStringLiteral(node.arguments[0]) &&
-        node.arguments[0].text.startsWith('.')
-      ) {
-        childVisits.push(
-          resolveLocalImport(absolutePath, node.arguments[0].text).then((resolvedImport) =>
-            visitSourceFile(resolvedImport),
-          ),
-        );
-      }
-
-      await Promise.all(node.getChildren(sourceFile).map((child) => visitNode(child)));
-    };
-
-    await visitNode(sourceFile);
+    for (const specifier of localImportSpecifiers(sourceCode)) {
+      childVisits.push(
+        resolveLocalImport(absolutePath, specifier).then((resolvedImport) =>
+          visitSourceFile(resolvedImport),
+        ),
+      );
+    }
     await Promise.all(childVisits);
   };
 

package/dist/repo/sdk/src/types.ts

@@ -114,6 +114,27 @@ export interface ToolDefinition {
   resultIdentityGetters?: Record<string, string[]>;
   /** Whether the output is a direct object or wrapped in a `result` envelope. */
   rowContextShape?: 'direct' | 'result_envelope';
+  /** Search relevance score returned by ranked tool search. */
+  search_score?: number;
+  /** Search match snippets returned by ranked tool search. */
+  search_matches?: Array<{
+    field: string;
+    value: string;
+    term?: string;
+  }>;
+}
+
+export interface ToolSearchOptions {
+  query?: string;
+  categories?: string;
+  searchTerms?: string;
+  searchMode?: 'v1' | 'v2';
+  includeSearchDebug?: boolean;
+}
+
+export interface ToolSearchResult {
+  tools: ToolDefinition[];
+  search_fallback_to_category?: boolean;
 }
 
 /**
@@ -201,6 +222,8 @@ export interface PlayProgressStatus {
   totalRows?: number;
   /** Accumulated log lines from `ctx.log()`. Grows monotonically. */
   logs: string[];
+  /** Zero-based offset of the first returned log line when a tail cursor is used. */
+  logOffset?: number;
   /** Error message if the play has failed. */
   error?: string;
 }
@@ -606,6 +629,8 @@ export interface StartPlayRunRequest {
   artifactStorageKey?: string;
   /** Source snapshot already validated while registering this artifact. */
   sourceCode?: string;
+  /** Source graph snapshots for local helper files included in cloud preflight. */
+  sourceFiles?: Record<string, string>;
   /** Static pipeline already produced while registering this artifact. */
   staticPipeline?: unknown;
   /** Artifact content hash already validated while registering this artifact. */

package/dist/repo/sdk/src/version.ts

@@ -1,2 +1,2 @@
-export const SDK_VERSION = "0.1.12";
-export const SDK_API_CONTRACT = "2026-04-plays-v1";
+export const SDK_VERSION = "0.1.19";
+export const SDK_API_CONTRACT = "2026-05-runs-v2";