trickle-cli 0.1.3 → 0.1.5

package/dist/index.js

@@ -39,6 +39,7 @@ const unpack_1 = require("./commands/unpack");
 const run_1 = require("./commands/run");
 const annotate_1 = require("./commands/annotate");
 const stubs_1 = require("./commands/stubs");
+const vars_1 = require("./commands/vars");
 const program = new commander_1.Command();
 program
     .name("trickle")
@@ -387,6 +388,17 @@ program
     .action(async (dir, opts) => {
     await (0, stubs_1.stubsCommand)(dir, opts);
 });
+// trickle vars
+program
+    .command("vars")
+    .description("Show captured variable types and sample values from runtime observations")
+    .option("-f, --file <file>", "Filter by file path or module name")
+    .option("-m, --module <module>", "Filter by module name")
+    .option("--json", "Output raw JSON")
+    .option("--tensors", "Show only tensor/ndarray variables")
+    .action(async (opts) => {
+    await (0, vars_1.varsCommand)(opts);
+});
 // trickle annotate <file>
 program
     .command("annotate <file>")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trickle-cli",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "CLI for trickle runtime type observability",
   "bin": {
     "trickle": "dist/index.js"

package/src/api-client.ts

@@ -256,7 +256,7 @@ export async function fetchFunctionSamples(): Promise<FunctionSample[]> {
   for (const fn of functions) {
     try {
       const data = await fetchJson<{ snapshots: Array<{ sample_input: unknown; sample_output: unknown }> }>(
-        `/api/types/${encodeURIComponent(fn.function_name)}`
+        `/api/types/${fn.id}`
       );
       if (data.snapshots && data.snapshots.length > 0) {
         const snap = data.snapshots[0];

package/src/commands/init.ts

@@ -46,11 +46,13 @@ function detectProject(dir: string, forcePython: boolean): ProjectInfo {
   if (fs.existsSync(tsPath)) {
     info.hasTsConfig = true;
     try {
-      // Strip comments (simple approach: remove // and /* */ comments)
+      // Strip comments but preserve glob patterns like /**/*.ts
       const raw = fs.readFileSync(tsPath, "utf-8");
+      // Only strip // comments that are NOT inside strings
+      // And /* */ comments that are NOT inside strings (careful with globs)
       const cleaned = raw
         .replace(/\/\/.*$/gm, "")
-        .replace(/\/\*[\s\S]*?\*\//g, "");
+        .replace(/("[^"]*")|\/\*[\s\S]*?\*\//g, (match, str) => str || "");
       info.tsConfig = JSON.parse(cleaned);
     } catch {
       // ignore parse errors
@@ -206,7 +208,7 @@ function writeInitialTypes(trickleDir: string, isPython: boolean): void {
 function updateTsConfig(dir: string, info: ProjectInfo): boolean {
   const tsConfigPath = path.join(dir, "tsconfig.json");
 
-  if (!info.hasTsConfig || !info.tsConfig) {
+  if (!info.hasTsConfig) {
     // No tsconfig — create a minimal one that includes .trickle
     if (!info.isPython) {
       const newConfig = {
@@ -227,25 +229,52 @@ function updateTsConfig(dir: string, info: ProjectInfo): boolean {
     return false;
   }
 
-  // Read the raw file to preserve formatting as much as possible
+  // Use text-based insertion to preserve formatting and glob patterns
+  // (JSON.parse + stringify corrupts /**/ globs by treating them as comments)
   const raw = fs.readFileSync(tsConfigPath, "utf-8");
-  const config = info.tsConfig;
 
   // Check if .trickle is already included
-  const include = config.include as string[] | undefined;
-  if (include && include.some((p: string) => p === ".trickle" || p.startsWith(".trickle/"))) {
-    return false; // Already configured
+  if (raw.includes(".trickle")) return false;
+
+  // Find the "include" array and insert ".trickle" at the end
+  const includeMatch = raw.match(/"include"\s*:\s*\[([^\]]*)\]/);
+  if (includeMatch) {
+    const bracket = includeMatch.index! + includeMatch[0].length - 1; // position of ]
+    const inside = includeMatch[1];
+    // Detect if it's single-line or multi-line
+    if (inside.includes("\n")) {
+      // Multi-line — add before the closing bracket with same indentation
+      const lastEntry = inside.match(/.*\S[^\n]*/g);
+      const indent = lastEntry ? lastEntry[lastEntry.length - 1].match(/^(\s*)/)?.[1] || "        " : "        ";
+      const updated = raw.slice(0, bracket) + `,\n${indent}".trickle"` + raw.slice(bracket);
+      fs.writeFileSync(tsConfigPath, updated, "utf-8");
+    } else {
+      // Single-line: ["src/**/*.ts", "tmp/**/*.ts"] → add ".trickle"
+      const updated = raw.slice(0, bracket) + ', ".trickle"' + raw.slice(bracket);
+      fs.writeFileSync(tsConfigPath, updated, "utf-8");
+    }
+    return true;
   }
 
-  // Add .trickle to include array
-  if (include) {
-    include.push(".trickle");
-  } else {
-    (config as Record<string, unknown>).include = ["src", ".trickle"];
+  // No include array — add one after compilerOptions closing brace
+  const compilerEnd = raw.match(/"compilerOptions"\s*:\s*\{/);
+  if (compilerEnd) {
+    // Find the closing brace of compilerOptions
+    const startBrace = raw.indexOf("{", compilerEnd.index! + compilerEnd[0].length - 1);
+    let depth = 1;
+    let pos = startBrace + 1;
+    while (pos < raw.length && depth > 0) {
+      if (raw[pos] === "{") depth++;
+      else if (raw[pos] === "}") depth--;
+      pos++;
+    }
+    // pos is now right after the closing brace of compilerOptions
+    const updated = raw.slice(0, pos) + `,\n    "include": ["src", ".trickle"]` + raw.slice(pos);
+    fs.writeFileSync(tsConfigPath, updated, "utf-8");
+    return true;
   }
 
-  fs.writeFileSync(tsConfigPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
-  return true;
+  return false;
 }
 
 function updatePackageJson(dir: string, info: ProjectInfo): { scriptsAdded: string[] } {
@@ -302,6 +331,100 @@ function updatePackageJson(dir: string, info: ProjectInfo): { scriptsAdded: stri
   return { scriptsAdded: added };
 }
 
+function updateVitestConfig(dir: string): boolean {
+  // Look for vitest.config.ts, vitest.config.js, vitest.config.mts, vite.config.ts, vite.config.js
+  const candidates = [
+    "vitest.config.ts",
+    "vitest.config.js",
+    "vitest.config.mts",
+    "vite.config.ts",
+    "vite.config.js",
+  ];
+
+  let configFile: string | null = null;
+  for (const c of candidates) {
+    if (fs.existsSync(path.join(dir, c))) {
+      configFile = c;
+      break;
+    }
+  }
+
+  if (!configFile) return false;
+
+  const configPath = path.join(dir, configFile);
+  const content = fs.readFileSync(configPath, "utf-8");
+
+  // Already has tricklePlugin
+  if (content.includes("tricklePlugin")) return false;
+
+  // Find the import section end and plugins array
+  const lines = content.split("\n");
+  let lastImportLine = -1;
+  let pluginsLine = -1;
+  let pluginsArrayContent = "";
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^\s*import\s/.test(line)) {
+      // Track multi-line imports
+      lastImportLine = i;
+      if (!line.includes(";") && !line.includes("from")) {
+        // Multi-line import — find the closing line
+        for (let j = i + 1; j < lines.length; j++) {
+          if (lines[j].includes("from")) {
+            lastImportLine = j;
+            break;
+          }
+        }
+      }
+    }
+    if (/plugins\s*:\s*\[/.test(line)) {
+      pluginsLine = i;
+      pluginsArrayContent = line;
+    }
+  }
+
+  if (lastImportLine === -1) return false;
+
+  // Add import after last import
+  const importLine = `import { tricklePlugin } from "trickle-observe/vite-plugin";`;
+  lines.splice(lastImportLine + 1, 0, importLine);
+
+  // Adjust pluginsLine index since we inserted a line
+  if (pluginsLine > lastImportLine) {
+    pluginsLine += 1;
+  }
+
+  // Add tricklePlugin() to plugins array
+  if (pluginsLine !== -1) {
+    const line = lines[pluginsLine];
+    // Check if plugins array is on one line: plugins: [something()],
+    if (/plugins\s*:\s*\[.*\]/.test(line)) {
+      // Insert tricklePlugin() before the closing bracket
+      lines[pluginsLine] = line.replace(/\]/, ", tricklePlugin()]");
+    } else {
+      // Multi-line plugins — add after the opening bracket line
+      const indent = line.match(/^(\s*)/)?.[1] || "";
+      const innerIndent = indent + "    ";
+      lines.splice(pluginsLine + 1, 0, `${innerIndent}tricklePlugin(),`);
+    }
+  } else {
+    // No plugins array found — need to add one
+    // Find defineConfig({ and add plugins after it
+    for (let i = 0; i < lines.length; i++) {
+      if (/defineConfig\s*\(\s*\{/.test(lines[i])) {
+        const indent = lines[i].match(/^(\s*)/)?.[1] || "";
+        const innerIndent = indent + "    ";
+        lines.splice(i + 1, 0, `${innerIndent}plugins: [tricklePlugin()],`);
+        break;
+      }
+    }
+  }
+
+  fs.writeFileSync(configPath, lines.join("\n"), "utf-8");
+  return true;
+}
+
 function updateGitignore(dir: string): boolean {
   const giPath = path.join(dir, ".gitignore");
   let content = "";
@@ -379,7 +502,15 @@ export async function initCommand(opts: InitOptions): Promise<void> {
     }
   }
 
-  // Step 5: Update package.json scripts
+  // Step 5: Update vitest/vite config with tricklePlugin
+  if (!info.isPython) {
+    const vitestUpdated = updateVitestConfig(dir);
+    if (vitestUpdated) {
+      console.log(`  ${chalk.green("~")} Updated ${chalk.bold("vitest.config.ts")} — added tricklePlugin() for variable tracing`);
+    }
+  }
+
+  // Step 6: Update package.json scripts
   if (info.hasPackageJson) {
     const { scriptsAdded } = updatePackageJson(dir, info);
     if (scriptsAdded.length > 0) {
@@ -389,13 +520,13 @@ export async function initCommand(opts: InitOptions): Promise<void> {
     }
   }
 
-  // Step 6: Update .gitignore
+  // Step 7: Update .gitignore
   const giUpdated = updateGitignore(dir);
   if (giUpdated) {
     console.log(`  ${chalk.green("~")} Updated ${chalk.bold(".gitignore")} — added .trickle/`);
   }
 
-  // Step 7: Print next steps
+  // Step 8: Print next steps
   console.log("");
   console.log(chalk.bold("  Next steps:"));
   console.log("");
@@ -412,6 +543,7 @@ export async function initCommand(opts: InitOptions): Promise<void> {
   console.log("");
   console.log(chalk.gray("  Other commands:"));
   console.log(chalk.gray("     trickle functions         — list observed functions"));
+  console.log(chalk.gray("     trickle vars              — list captured variable types + values"));
   console.log(chalk.gray("     trickle types <name>      — see types + sample data"));
   console.log(chalk.gray("     trickle annotate src/     — add type annotations to source files"));
 

package/src/commands/run.ts

@@ -151,10 +151,17 @@ function autoDetectCommand(input: string): string {
 }
 
 function findTsRunner(): string {
+  const { execSync } = require("child_process");
+
+  // Add node_modules/.bin to PATH so local binaries are found
+  const binPath = path.join(process.cwd(), "node_modules", ".bin");
+  const currentPath = process.env.PATH || "";
+  const augmentedPath = currentPath.includes(binPath) ? currentPath : `${binPath}${path.delimiter}${currentPath}`;
+  const execOpts = { stdio: "ignore" as const, env: { ...process.env, PATH: augmentedPath } };
+
   // Check for tsx (fastest, most compatible)
   try {
-    const { execSync } = require("child_process");
-    execSync("tsx --version", { stdio: "ignore" });
+    execSync("tsx --version", execOpts);
     return "tsx";
   } catch {
     // not available
@@ -162,8 +169,7 @@ function findTsRunner(): string {
 
   // Check for ts-node
   try {
-    const { execSync } = require("child_process");
-    execSync("ts-node --version", { stdio: "ignore" });
+    execSync("ts-node --version", execOpts);
     return "ts-node";
   } catch {
     // not available
@@ -171,8 +177,7 @@ function findTsRunner(): string {
 
   // Check for bun (supports TS natively)
   try {
-    const { execSync } = require("child_process");
-    execSync("bun --version", { stdio: "ignore" });
+    execSync("bun --version", execOpts);
     return "bun";
   } catch {
     // not available
@@ -447,6 +452,17 @@ async function executeSingleRun(
     }
   }
 
+  // Show variable/tensor summary if variables.jsonl exists
+  const varsJsonlPath = path.join(localDir, "variables.jsonl");
+  if (fs.existsSync(varsJsonlPath)) {
+    try {
+      const { showVarsSummary } = await import("./vars");
+      showVarsSummary(varsJsonlPath);
+    } catch {
+      // vars module not available, skip
+    }
+  }
+
   console.log(chalk.gray("  " + "─".repeat(50)));
   console.log("");
 
@@ -538,6 +554,9 @@ function startLiveBackendTypes(sourceFile: string): () => void {
   const baseName = path.basename(sourceFile, ext);
   const sidecarName = isPython ? `${baseName}.pyi` : `${baseName}.d.ts`;
   const sidecarPath = path.join(dir, sidecarName);
+  // Also check .trickle/types/ where auto-codegen now writes
+  const trickleDir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+  const trickleTypesPath = path.join(trickleDir, 'types', `${baseName}.d.ts`);
 
   const poll = async () => {
     if (stopped) return;
@@ -545,8 +564,10 @@ function startLiveBackendTypes(sourceFile: string): () => void {
       const { stubsCommand } = await import("./stubs");
       await stubsCommand(dir, { silent: true });
 
-      if (fs.existsSync(sidecarPath)) {
-        const content = fs.readFileSync(sidecarPath, "utf-8");
+      // Check both old sidecar path and new .trickle/types/ path
+      const effectivePath = fs.existsSync(trickleTypesPath) ? trickleTypesPath : sidecarPath;
+      if (fs.existsSync(effectivePath)) {
+        const content = fs.readFileSync(effectivePath, "utf-8");
         const funcCount = (content.match(/export declare function/g) || []).length;
 
         if (funcCount > lastFunctionCount) {
@@ -635,12 +656,16 @@ async function autoGenerateSidecar(filePath: string): Promise<void> {
     const { stubsCommand } = await import("./stubs");
     await stubsCommand(dir, { silent: true });
 
-    // Check if the sidecar was generated
-    if (fs.existsSync(sidecarPath)) {
-      const stats = fs.statSync(sidecarPath);
+    // Check if types were generated (either sidecar or .trickle/types/)
+    const tDir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+    const tTypesPath = path.join(tDir, 'types', `${baseName}.d.ts`);
+    const effectiveSidecar = fs.existsSync(tTypesPath) ? tTypesPath : sidecarPath;
+    const displayName = fs.existsSync(tTypesPath) ? `${baseName}.d.ts` : sidecarName;
+    if (fs.existsSync(effectiveSidecar)) {
+      const stats = fs.statSync(effectiveSidecar);
       if (stats.size > 0) {
         console.log(
-          chalk.green(`\n  Types written to ${chalk.bold(sidecarName)}`),
+          chalk.green(`\n  Types written to ${chalk.bold(displayName)}`),
         );
       }
     }
@@ -953,9 +978,17 @@ function injectObservation(
     const useEsm = isEsmFile(command) && observeEsmPath;
 
     if (useEsm) {
+      // Use both ESM hooks (for exported functions) and CJS hook (for Express auto-detection)
+      const modified = command.replace(
+        new RegExp(`^${runner}\\s`),
+        `${runner} -r ${observePath} --import ${observeEsmPath} `,
+      );
+      return { instrumentedCommand: modified, env };
+    } else if (runner === "tsx") {
+      // tsx always uses ESM internally — inject both CJS and ESM hooks
       const modified = command.replace(
         new RegExp(`^${runner}\\s`),
-        `${runner} --import ${observeEsmPath} `,
+        `${runner} -r ${observePath} --import ${observeEsmPath} `,
       );
       return { instrumentedCommand: modified, env };
     } else {
@@ -1060,10 +1093,15 @@ function runProcess(
   env: Record<string, string>,
 ): Promise<number> {
   return new Promise((resolve) => {
+    // Add node_modules/.bin to PATH so local binaries (tsx, ts-node, etc.) are found
+    const binPath = path.join(process.cwd(), "node_modules", ".bin");
+    const currentPath = process.env.PATH || "";
+    const augmentedPath = currentPath.includes(binPath) ? currentPath : `${binPath}${path.delimiter}${currentPath}`;
+
     const proc = spawn(command, [], {
       stdio: "inherit",
       shell: true,
-      env: { ...process.env, ...env },
+      env: { ...process.env, ...env, PATH: augmentedPath },
     });
 
     proc.on("error", (err) => {