deepline 0.3.89 → 0.3.91

package/dist/bundling-sources/shared_libs/plays/local-file-discovery.ts

@@ -0,0 +1,385 @@
+import { createHash } from 'node:crypto';
+import { readFile, stat } from 'node:fs/promises';
+import {
+  extname,
+  resolve,
+  dirname,
+  isAbsolute,
+  join,
+  relative,
+} from 'node:path';
+import * as ts from 'typescript';
+
+export interface PlayLocalFileReference {
+  sourceFragment: string;
+  logicalPath: string;
+  absolutePath: string;
+  bytes: number;
+  contentHash: string;
+  contentType: string;
+}
+
+export interface PlayLocalFileDiscoveryError {
+  sourceFragment: string;
+  message: string;
+}
+
+export interface PlayLocalFileDiscoveryResult {
+  files: PlayLocalFileReference[];
+  unresolved: PlayLocalFileDiscoveryError[];
+}
+
+type ConstMap = Map<string, string>;
+const SOURCE_EXTENSIONS = [
+  '.ts',
+  '.tsx',
+  '.mts',
+  '.cts',
+  '.js',
+  '.jsx',
+  '.mjs',
+  '.cjs',
+  '.json',
+];
+const TEXT_IMPORT_EXTENSIONS = new Set(['.md', '.txt']);
+
+function isTextImportFile(filePath: string): boolean {
+  return TEXT_IMPORT_EXTENSIONS.has(extname(filePath));
+}
+
+function sha256(buffer: Buffer): string {
+  return createHash('sha256').update(buffer).digest('hex');
+}
+
+function contentTypeForFile(filePath: string): string {
+  const extension = extname(filePath).toLowerCase();
+  if (extension === '.csv') return 'text/csv';
+  if (extension === '.json') return 'application/json';
+  if (extension === '.txt') return 'text/plain';
+  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 extractSourceFragment(source: string, node: ts.Node): string {
+  return source.slice(node.getStart(), node.getEnd()).trim();
+}
+
+function referencesInputIdentifier(node: ts.Node): boolean {
+  if (ts.isIdentifier(node) && node.text === 'input') {
+    return true;
+  }
+
+  return node.getChildren().some((child) => referencesInputIdentifier(child));
+}
+
+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';
+  }
+
+  if (ts.isParenthesizedExpression(node)) {
+    return isRuntimeInputExpression(node.expression);
+  }
+
+  if (
+    ts.isBinaryExpression(node) &&
+    (node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken ||
+      node.operatorToken.kind === ts.SyntaxKind.BarBarToken)
+  ) {
+    return (
+      isRuntimeInputExpression(node.left) ||
+      isRuntimeInputExpression(node.right)
+    );
+  }
+
+  if (ts.isConditionalExpression(node)) {
+    return (
+      isRuntimeInputExpression(node.condition) ||
+      isRuntimeInputExpression(node.whenTrue) ||
+      isRuntimeInputExpression(node.whenFalse)
+    );
+  }
+
+  return referencesInputIdentifier(node);
+}
+
+function resolveStringExpression(
+  node: ts.Expression,
+  constants: ConstMap,
+): string | null {
+  if (
+    ts.isStringLiteralLike(node) ||
+    ts.isNoSubstitutionTemplateLiteral(node)
+  ) {
+    return node.text;
+  }
+
+  if (ts.isParenthesizedExpression(node)) {
+    return resolveStringExpression(node.expression, constants);
+  }
+
+  if (ts.isIdentifier(node)) {
+    return constants.get(node.text) ?? null;
+  }
+
+  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;
+      }
+      value += resolved + span.literal.text;
+    }
+    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;
+    }
+    return left + right;
+  }
+
+  return null;
+}
+
+function collectTopLevelStringConstants(sourceFile: ts.SourceFile): ConstMap {
+  const constants: ConstMap = new Map();
+
+  for (const statement of sourceFile.statements) {
+    if (!ts.isVariableStatement(statement)) {
+      continue;
+    }
+
+    if (!(statement.declarationList.flags & ts.NodeFlags.Const)) {
+      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);
+      }
+    }
+  }
+
+  return constants;
+}
+
+async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isPathInsideDirectory(filePath: string, directory: string): boolean {
+  const relativePath = relative(directory, filePath);
+  return (
+    relativePath === '' ||
+    (!relativePath.startsWith('..') && !isAbsolute(relativePath))
+  );
+}
+
+async function resolveLocalImport(
+  fromFile: string,
+  specifier: string,
+): Promise<string> {
+  const base = isAbsolute(specifier)
+    ? resolve(specifier)
+    : resolve(dirname(fromFile), specifier);
+  const candidates: string[] = [base];
+  const explicitExtension = extname(base).toLowerCase();
+
+  if (!explicitExtension) {
+    candidates.push(
+      ...SOURCE_EXTENSIONS.map((extension) => `${base}${extension}`),
+    );
+    candidates.push(
+      ...SOURCE_EXTENSIONS.map((extension) => join(base, `index${extension}`)),
+    );
+  } else if (['.js', '.jsx', '.mjs', '.cjs'].includes(explicitExtension)) {
+    const stem = base.slice(0, -explicitExtension.length);
+    candidates.push(
+      ...SOURCE_EXTENSIONS.map((extension) => `${stem}${extension}`),
+    );
+  }
+
+  for (const candidate of candidates) {
+    if (await fileExists(candidate)) {
+      return candidate;
+    }
+  }
+
+  throw new Error(
+    `Could not resolve local import "${specifier}" from ${fromFile}`,
+  );
+}
+
+export async function discoverPackagedLocalFiles(
+  entryFile: string,
+): Promise<PlayLocalFileDiscoveryResult> {
+  const absoluteEntryFile = resolve(entryFile);
+  const packagingRoot = dirname(absoluteEntryFile);
+  const files = new Map<string, PlayLocalFileReference>();
+  const unresolved: PlayLocalFileDiscoveryError[] = [];
+  const visitedFiles = new Set<string>();
+
+  const visitSourceFile = async (filePath: string): Promise<void> => {
+    const absolutePath = resolve(filePath);
+    if (visitedFiles.has(absolutePath)) {
+      return;
+    }
+    visitedFiles.add(absolutePath);
+
+    const sourceCode = await readFile(absolutePath, 'utf-8');
+    if (isTextImportFile(absolutePath)) {
+      return;
+    }
+    const sourceFile = ts.createSourceFile(
+      absolutePath,
+      sourceCode,
+      ts.ScriptTarget.Latest,
+      true,
+      ts.ScriptKind.TS,
+    );
+    const constants = collectTopLevelStringConstants(sourceFile);
+    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) {
+          unresolved.push({
+            sourceFragment: 'ctx.csv()',
+            message:
+              'ctx.csv() requires a file path string or input reference.',
+          });
+        } else if (!isRuntimeInputExpression(argument)) {
+          const resolvedPath = resolveStringExpression(argument, constants);
+          if (resolvedPath == null) {
+            unresolved.push({
+              sourceFragment: extractSourceFragment(sourceCode, argument),
+              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(
+              /* turbopackIgnore: true */ absoluteCsvPath,
+            );
+            const stats = await stat(
+              /* turbopackIgnore: true */ absoluteCsvPath,
+            );
+            files.set(absoluteCsvPath, {
+              sourceFragment: extractSourceFragment(sourceCode, argument),
+              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);
+    await Promise.all(childVisits);
+  };
+
+  await visitSourceFile(absoluteEntryFile);
+
+  return {
+    files: [...files.values()],
+    unresolved,
+  };
+}
+
+export interface PlayStagedFileRef {
+  storageKind: 'r2';
+  storageKey: string;
+  logicalPath: string;
+  fileName: string;
+  contentHash: string;
+  contentType: string;
+  bytes: number;
+}

package/dist/bundling-sources/shared_libs/plays/play-grep-search.ts

@@ -0,0 +1,112 @@
+// Convex limits its final prefix-search term to 32 UTF-8 bytes, so the public
+// query must stay below that boundary. Keep this normalization aligned with
+// the indexed corpus and reject unsupported queries at the API boundary.
+export const CONVEX_PLAY_GREP_SEARCH_TERM_MAX_BYTES = 31;
+export const CONVEX_PLAY_GREP_SEARCH_MAX_TERMS = 16;
+
+const CONVEX_PLAY_GREP_SEARCH_TERM_PATTERN = /[\p{L}\p{N}]+/gu;
+
+export type PlayGrepMatch = {
+  field: 'name' | 'description' | 'provider' | 'source';
+  terms: string[];
+};
+
+/** Return searchable raw terms for the public response filter. */
+export function extractPlayGrepSearchTerms(value: string): string[] {
+  return value.match(CONVEX_PLAY_GREP_SEARCH_TERM_PATTERN) ?? [];
+}
+
+/**
+ * Match the indexed grep corpus representation.
+ */
+export function normalizePlayGrepSearchQuery(value: string): string {
+  return value.toLowerCase();
+}
+
+/**
+ * Count the terms the API will send to Convex. Request validation keeps an
+ * accepted query within Convex's 16-term full-text-search limit.
+ */
+export function countNormalizedPlayGrepSearchTerms(value: string): number {
+  return extractPlayGrepSearchTerms(normalizePlayGrepSearchQuery(value)).length;
+}
+
+/** True when a query term exceeds Convex's usable full-text-search limit. */
+export function hasOverlongPlayGrepSearchTerm(value: string): boolean {
+  const encoder = new TextEncoder();
+  return extractPlayGrepSearchTerms(normalizePlayGrepSearchQuery(value)).some(
+    (term) =>
+      encoder.encode(term).byteLength > CONVEX_PLAY_GREP_SEARCH_TERM_MAX_BYTES,
+  );
+}
+
+function searchableTerms(value: string | null | undefined): Set<string> {
+  return new Set(
+    extractPlayGrepSearchTerms(normalizePlayGrepSearchQuery(value ?? '')),
+  );
+}
+
+function matchingTerms(
+  queryTerms: readonly string[],
+  value: string | null | undefined,
+): string[] {
+  const valueTerms = searchableTerms(value);
+  const finalTermIndex = queryTerms.length - 1;
+  const hasTermPrefixMatch = (queryTerm: string) => {
+    for (const valueTerm of valueTerms) {
+      if (valueTerm.startsWith(queryTerm)) return true;
+    }
+    return false;
+  };
+  return [
+    ...new Set(
+      queryTerms.filter((queryTerm, index) =>
+        index === finalTermIndex
+          ? hasTermPrefixMatch(queryTerm)
+          : valueTerms.has(queryTerm),
+      ),
+    ),
+  ];
+}
+
+/**
+ * Explain an indexed result without returning authored source. The direct
+ * Convex index remains the sole matcher; this only reports which indexed
+ * field accounted for each accepted term.
+ */
+export function buildPlayGrepMatches(input: {
+  query: string;
+  name: string;
+  description?: string | null;
+  providers?: readonly string[] | null;
+}): PlayGrepMatch[] {
+  const queryTerms = extractPlayGrepSearchTerms(
+    normalizePlayGrepSearchQuery(input.query),
+  );
+  if (queryTerms.length === 0) return [];
+
+  const fields: Array<{
+    field: Exclude<PlayGrepMatch['field'], 'source'>;
+    value: string;
+  }> = [
+    { field: 'name', value: input.name },
+    { field: 'description', value: input.description ?? '' },
+    { field: 'provider', value: (input.providers ?? []).join(' ') },
+  ];
+  const matches: PlayGrepMatch[] = [];
+  const accountedFor = new Set<string>();
+  for (const { field, value } of fields) {
+    const terms = matchingTerms(queryTerms, value);
+    if (terms.length === 0) continue;
+    terms.forEach((term) => accountedFor.add(term));
+    matches.push({ field, terms });
+  }
+
+  const sourceTerms = [
+    ...new Set(queryTerms.filter((term) => !accountedFor.has(term))),
+  ];
+  if (sourceTerms.length > 0) {
+    matches.push({ field: 'source', terms: sourceTerms });
+  }
+  return matches;
+}

package/dist/bundling-sources/shared_libs/plays/play-reference.ts

@@ -0,0 +1,117 @@
+export const PREBUILT_PLAY_NAMESPACE = 'prebuilt';
+export const SELF_PLAY_NAMESPACE = 'self';
+
+export type PlayReference =
+  | {
+      kind: 'bare';
+      reference: string;
+      name: string;
+    }
+  | {
+      kind: 'prebuilt';
+      reference: string;
+      name: string;
+    }
+  | {
+      kind: 'self';
+      reference: string;
+      name: string;
+    }
+  | {
+      kind: 'org';
+      reference: string;
+      ownerSlug: string;
+      name: string;
+    }
+  | {
+      kind: 'invalid';
+      reference: string;
+    };
+
+export function buildPlayReference(
+  ownerSlug: string,
+  playName: string,
+): string {
+  return `${ownerSlug.trim()}/${playName.trim()}`;
+}
+
+export function buildPrebuiltPlayReference(playName: string): string {
+  return buildPlayReference(PREBUILT_PLAY_NAMESPACE, playName);
+}
+
+export function buildSelfPlayReference(playName: string): string {
+  return buildPlayReference(SELF_PLAY_NAMESPACE, playName);
+}
+
+export function parsePlayReference(reference: string): PlayReference {
+  const trimmed = reference.trim();
+  if (!trimmed) {
+    return { kind: 'invalid', reference: trimmed };
+  }
+
+  const segments = trimmed.split('/');
+  if (segments.length === 1) {
+    return { kind: 'bare', reference: trimmed, name: trimmed };
+  }
+  if (segments.length !== 2) {
+    return { kind: 'invalid', reference: trimmed };
+  }
+
+  const [rawOwnerSlug = '', rawName = ''] = segments;
+  const ownerSlug = rawOwnerSlug.trim();
+  const name = rawName.trim();
+  if (!ownerSlug || !name) {
+    return { kind: 'invalid', reference: trimmed };
+  }
+
+  const normalizedOwnerSlug = ownerSlug.toLowerCase();
+  if (normalizedOwnerSlug === PREBUILT_PLAY_NAMESPACE) {
+    return {
+      kind: 'prebuilt',
+      reference: buildPrebuiltPlayReference(name),
+      name,
+    };
+  }
+  if (normalizedOwnerSlug === SELF_PLAY_NAMESPACE) {
+    return {
+      kind: 'self',
+      reference: buildSelfPlayReference(name),
+      name,
+    };
+  }
+
+  return {
+    kind: 'org',
+    reference: buildPlayReference(ownerSlug, name),
+    ownerSlug,
+    name,
+  };
+}
+
+export function isPrebuiltPlayReference(reference: string): boolean {
+  return parsePlayReference(reference).kind === 'prebuilt';
+}
+
+/**
+ * Resolve every spelling that can identify a play owned by the current org to
+ * its stored bare name. This is the single ownership boundary shared by
+ * CLI/API lookup, preflight static-contract lookup, and runtime ctx.runPlay.
+ */
+export function resolveOwnedPlayReferenceName(
+  reference: string,
+  ownerSlug?: string | null,
+): string | null {
+  const parsed = parsePlayReference(reference);
+  if (parsed.kind === 'bare' || parsed.kind === 'self') {
+    return parsed.name;
+  }
+  if (parsed.kind !== 'org') {
+    return null;
+  }
+
+  const normalizedOwnerSlug = ownerSlug?.trim().toLowerCase() ?? '';
+  return normalizedOwnerSlug &&
+    parsed.ownerSlug.trim().toLowerCase() === normalizedOwnerSlug
+    ? parsed.name
+    : null;
+}