@grekt/cli 6.42.0 → 6.43.0-beta.1

package/dist/index.js

@@ -69100,25 +69100,43 @@ var __getProtoOf2 = Object.getPrototypeOf;
 var __defProp2 = Object.defineProperty;
 var __getOwnPropNames2 = Object.getOwnPropertyNames;
 var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+function __accessProp2(key) {
+  return this[key];
+}
+var __toESMCache_node2;
+var __toESMCache_esm2;
 var __toESM2 = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache2 = isNodeMode ? __toESMCache_node2 ??= new WeakMap : __toESMCache_esm2 ??= new WeakMap;
+    var cached = cache2.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create2(__getProtoOf2(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames2(mod))
     if (!__hasOwnProp2.call(to, key))
       __defProp2(to, key, {
-        get: () => mod[key],
+        get: __accessProp2.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache2.set(mod, to);
   return to;
 };
 var __commonJS2 = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue2 = (v) => v;
+function __exportSetter2(name2, newValue) {
+  this[name2] = __returnValue2.bind(null, newValue);
+}
 var __export2 = (target, all) => {
   for (var name2 in all)
     __defProp2(target, name2, {
       get: all[name2],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name2] = () => newValue
+      set: __exportSetter2.bind(all, name2)
     });
 };
 var __require2 = /* @__PURE__ */ createRequire2(import.meta.url);
@@ -85174,10 +85192,15 @@ var StoredSessionSchema = exports_external.object({
   expires_at: exports_external.number().optional()
 });
 var TokensSchema = exports_external.record(exports_external.string(), exports_external.string());
+var EvalLocalConfigSchema = exports_external.object({
+  providers: exports_external.array(exports_external.string()).optional(),
+  server: exports_external.string().optional()
+});
 var LocalConfigSchema = exports_external.object({
   registries: exports_external.record(exports_external.string().regex(/^@/, "Registry scope must start with @"), RegistryEntrySchema).optional(),
   session: StoredSessionSchema.optional(),
-  tokens: TokensSchema.optional()
+  tokens: TokensSchema.optional(),
+  eval: EvalLocalConfigSchema.optional()
 });
 var ComponentTypeSchema = exports_external.enum(CATEGORIES);
 var WorkspaceConfigSchema = exports_external.object({
@@ -90151,6 +90174,169 @@ function verifyTrustSignature(artifactId, signature, key) {
     return false;
   return timingSafeEqual(signatureBuffer, expectedBuffer);
 }
+var EVALUABLE_CATEGORIES = ["agents", "skills", "commands"];
+var EvalAssertionSchema = exports_external.object({
+  type: exports_external.string(),
+  value: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]).optional(),
+  threshold: exports_external.number().optional(),
+  weight: exports_external.number().optional()
+});
+var EvalTestCaseSchema = exports_external.object({
+  description: exports_external.string().optional(),
+  vars: exports_external.record(exports_external.string(), exports_external.string()),
+  assert: exports_external.array(EvalAssertionSchema).min(1, "At least one assertion is required")
+});
+var EvalFileConfigSchema = exports_external.object({
+  provider: exports_external.string().optional(),
+  tests: exports_external.array(EvalTestCaseSchema).min(1, "At least one test case is required")
+});
+var EVAL_EXTENSION = ".eval.yaml";
+function collectFiles2(fs12, dir, basePath = "") {
+  const paths = [];
+  let entries;
+  try {
+    entries = fs12.readdir(dir);
+  } catch {
+    return paths;
+  }
+  for (const entry of entries) {
+    const fullPath = `${dir}/${entry}`;
+    const relativePath = basePath ? `${basePath}/${entry}` : entry;
+    try {
+      const stat = fs12.stat(fullPath);
+      if (stat.isDirectory) {
+        paths.push(...collectFiles2(fs12, fullPath, relativePath));
+      } else {
+        paths.push(relativePath);
+      }
+    } catch {}
+  }
+  return paths;
+}
+function discoverEvals(fs12, options2) {
+  const { artifactDir, artifactId, filter } = options2;
+  const evals = [];
+  const warnings = [];
+  const allFiles = collectFiles2(fs12, artifactDir);
+  const evalFiles = allFiles.filter((f) => f.endsWith(EVAL_EXTENSION));
+  for (const evalRelativePath of evalFiles) {
+    const evalFullPath = `${artifactDir}/${evalRelativePath}`;
+    const baseName = evalRelativePath.slice(0, -EVAL_EXTENSION.length);
+    const mdRelativePath = `${baseName}.md`;
+    const mdFullPath = `${artifactDir}/${mdRelativePath}`;
+    if (!fs12.exists(mdFullPath)) {
+      warnings.push({
+        evalFilePath: evalRelativePath,
+        message: `Skipped ${evalRelativePath}: no matching .md file found (expected ${mdRelativePath})`
+      });
+      continue;
+    }
+    let mdContent;
+    try {
+      mdContent = fs12.readFile(mdFullPath);
+    } catch {
+      warnings.push({
+        evalFilePath: evalRelativePath,
+        message: `Skipped ${evalRelativePath}: could not read ${mdRelativePath}`
+      });
+      continue;
+    }
+    const frontmatterResult = parseFrontmatter(mdContent);
+    if (!frontmatterResult.success) {
+      warnings.push({
+        evalFilePath: evalRelativePath,
+        message: `Skipped ${evalRelativePath}: ${mdRelativePath} has invalid or missing frontmatter`
+      });
+      continue;
+    }
+    const { frontmatter: frontmatter2, content: systemPrompt } = frontmatterResult.parsed;
+    const elementType = frontmatter2["grk-type"];
+    const elementName = frontmatter2["grk-name"];
+    if (!EVALUABLE_CATEGORIES.includes(elementType)) {
+      warnings.push({
+        evalFilePath: evalRelativePath,
+        message: `Skipped ${evalRelativePath}: ${elementType} is not evaluable (only agents, skills, commands)`
+      });
+      continue;
+    }
+    let evalYamlContent;
+    try {
+      evalYamlContent = fs12.readFile(evalFullPath);
+    } catch {
+      warnings.push({
+        evalFilePath: evalRelativePath,
+        message: `Skipped ${evalRelativePath}: file could not be read`
+      });
+      continue;
+    }
+    const parseResult = safeParseYaml(evalYamlContent, EvalFileConfigSchema, evalRelativePath);
+    if (!parseResult.success) {
+      const details = parseResult.error.details?.join(", ") ?? "";
+      warnings.push({
+        evalFilePath: evalRelativePath,
+        message: `Skipped ${evalRelativePath}: ${parseResult.error.message}${details ? ` (${details})` : ""}`
+      });
+      continue;
+    }
+    const evalConfig = parseResult.data;
+    if (filter?.elementName && elementName !== filter.elementName)
+      continue;
+    if (filter?.elementType && elementType !== filter.elementType)
+      continue;
+    evals.push({
+      artifactId,
+      elementName,
+      elementType,
+      elementPath: mdRelativePath,
+      systemPrompt: systemPrompt.trim(),
+      evalConfig,
+      evalFilePath: evalRelativePath
+    });
+  }
+  return { evals, warnings };
+}
+function calculateScore(passed, total) {
+  if (total === 0)
+    return 0;
+  return Math.round(passed / total * 100);
+}
+function scoreToGrade(score) {
+  if (score >= 95)
+    return "A";
+  if (score >= 80)
+    return "B";
+  if (score >= 65)
+    return "C";
+  if (score >= 50)
+    return "D";
+  return "F";
+}
+function summarizeResults(results) {
+  if (results.length === 0) {
+    return {
+      results: [],
+      overallScore: 0,
+      overallGrade: "F",
+      totalPassed: 0,
+      totalTests: 0,
+      totalIssues: 0
+    };
+  }
+  const totalPassed = results.reduce((sum, r) => sum + r.passed, 0);
+  const totalTests = results.reduce((sum, r) => sum + r.total, 0);
+  const totalIssues = results.reduce((sum, r) => sum + r.failures.length, 0);
+  const weightedSum = results.reduce((sum, r) => sum + r.score * r.total, 0);
+  const overallScore = totalTests > 0 ? Math.round(weightedSum / totalTests) : 0;
+  const overallGrade = scoreToGrade(overallScore);
+  return {
+    results,
+    overallScore,
+    overallGrade,
+    totalPassed,
+    totalTests,
+    totalIssues
+  };
+}
 
 // src/constants.ts
 var REGISTRY_HOST2 = "registry.grekt.com";
@@ -102328,6 +102514,9 @@ function detectArtifactBaseRef(artifactName) {
 function createArtifactTag(artifactName, version3) {
   const tag = `${artifactName}@${version3}`;
   exec(["tag", tag]);
+  if (process.env.CI) {
+    execOrNull(["push", "origin", tag]);
+  }
 }
 
 // src/workspace/workspace.ts
@@ -104181,6 +104370,384 @@ var untrustCommand = new Command("untrust").description("Remove trusted status f
   success(`Removed trusted status from ${colors5.highlight(artifactId)}`);
 });
 
+// src/commands/eval.ts
+import { join as join35 } from "path";
+
+// src/eval/promptfoo-engine.ts
+function detectPromptfoo() {
+  try {
+    const result = Bun.spawnSync(["promptfoo", "--version"], { stdout: "pipe", stderr: "pipe" });
+    if (result.exitCode === 0)
+      return "global";
+  } catch {}
+  try {
+    const result = Bun.spawnSync(["npx", "promptfoo", "--version"], { stdout: "pipe", stderr: "pipe" });
+    if (result.exitCode === 0)
+      return "npx";
+  } catch {}
+  return "none";
+}
+function getCommand(mode) {
+  return mode === "npx" ? ["npx", "promptfoo"] : ["promptfoo"];
+}
+function assemblePromptfooConfig(config) {
+  return {
+    prompts: [
+      {
+        role: "system",
+        content: config.systemPrompt
+      },
+      {
+        role: "user",
+        content: "{{input}}"
+      }
+    ],
+    providers: [config.provider],
+    tests: config.tests.map((test) => ({
+      description: test.description,
+      vars: test.vars,
+      assert: test.assert.map((a) => ({
+        type: a.type,
+        ...a.value !== undefined && { value: a.value },
+        ...a.threshold !== undefined && { threshold: a.threshold },
+        ...a.weight !== undefined && { weight: a.weight }
+      }))
+    }))
+  };
+}
+function extractFailures(promptfooResults) {
+  let passed = 0;
+  let total = 0;
+  const failures = [];
+  for (const result of promptfooResults) {
+    const r = result;
+    const success2 = r.success;
+    total++;
+    if (success2) {
+      passed++;
+    } else {
+      const gradingResult = r.gradingResult;
+      const componentResults = gradingResult?.componentResults ?? [];
+      for (const component of componentResults) {
+        if (!component.pass) {
+          const assertion = component.assertion;
+          failures.push({
+            testDescription: r.description ?? `Test ${total}`,
+            assertionType: assertion?.type ?? "unknown",
+            expected: String(assertion?.value ?? ""),
+            actual: String(component.reason ?? "")
+          });
+        }
+      }
+      if (componentResults.length === 0) {
+        failures.push({
+          testDescription: r.description ?? `Test ${total}`,
+          assertionType: "unknown",
+          expected: "",
+          actual: String(gradingResult?.reason ?? "unknown error")
+        });
+      }
+    }
+  }
+  return { passed, total, failures };
+}
+function createPromptfooEngine() {
+  let mode = detectPromptfoo();
+  return {
+    name: "promptfoo",
+    isAvailable() {
+      return mode !== "none";
+    },
+    async ensureAvailable() {
+      if (mode !== "none")
+        return true;
+      const spin = spinner("Downloading promptfoo via npx...");
+      spin.start();
+      Bun.spawnSync(["npx", "promptfoo@latest", "--version"], { stdout: "pipe", stderr: "pipe" });
+      spin.stop();
+      mode = detectPromptfoo();
+      return mode !== "none";
+    },
+    async run(config) {
+      const promptfooConfig = assemblePromptfooConfig(config);
+      if (mode === "global") {
+        try {
+          const promptfoo = await import("promptfoo");
+          const evaluate = promptfoo.evaluate;
+          if (typeof evaluate === "function") {
+            const evaluateResult = await evaluate(promptfooConfig);
+            const results = evaluateResult.results ?? [];
+            return extractFailures(results);
+          }
+        } catch {}
+      }
+      return runViaCli(mode, promptfooConfig);
+    },
+    openReport() {
+      const cmd = getCommand(mode);
+      Bun.spawnSync([...cmd, "view"], { stdout: "inherit", stderr: "inherit" });
+    }
+  };
+}
+async function runViaCli(mode, promptfooConfig) {
+  const tempDir = `${process.env.TMPDIR ?? "/tmp"}/grekt-eval-${Date.now()}`;
+  const configPath = `${tempDir}/promptfoo-config.json`;
+  const outputPath = `${tempDir}/output.json`;
+  const { mkdirSync: mkdirSync3, writeFileSync: writeFileSync2, readFileSync: readFileSync2, rmSync: rmSync2 } = await import("fs");
+  mkdirSync3(tempDir, { recursive: true });
+  try {
+    writeFileSync2(configPath, JSON.stringify(promptfooConfig, null, 2));
+    const cmd = getCommand(mode);
+    const result = Bun.spawnSync([...cmd, "eval", "--config", configPath, "--output", outputPath, "--no-cache"], { stdout: "pipe", stderr: "pipe" });
+    if (result.exitCode !== 0) {
+      const stderr = result.stderr.toString();
+      throw new Error(`promptfoo eval failed: ${stderr}`);
+    }
+    const output = JSON.parse(readFileSync2(outputPath, "utf-8"));
+    const results = output.results ?? [];
+    return extractFailures(results);
+  } finally {
+    rmSync2(tempDir, { recursive: true, force: true });
+  }
+}
+
+// src/eval/engine-resolver.ts
+var AVAILABLE_ENGINES = [
+  {
+    name: "promptfoo",
+    description: "Open source LLM eval framework. Runs via npx if not installed",
+    create: createPromptfooEngine
+  }
+];
+async function resolveEvalEngine() {
+  for (const entry2 of AVAILABLE_ENGINES) {
+    const engine3 = entry2.create();
+    if (engine3.isAvailable())
+      return engine3;
+  }
+  newline();
+  info("No eval engine detected");
+  newline();
+  const selected = await esm_default6({
+    message: "Select an eval engine to use:",
+    choices: AVAILABLE_ENGINES.map((entry2) => ({
+      name: `${entry2.name} - ${entry2.description}`,
+      value: entry2.name
+    }))
+  });
+  const entry = AVAILABLE_ENGINES.find((e) => e.name === selected);
+  if (!entry)
+    return null;
+  const engine2 = entry.create();
+  const ready = await engine2.ensureAvailable();
+  if (!ready) {
+    newline();
+    error(`Failed to set up ${entry.name}`);
+    newline();
+    log("  Install it manually with one of:");
+    log(`    ${colors5.dim("$")} npm install -g ${entry.name}`);
+    log(`    ${colors5.dim("$")} brew install ${entry.name}`);
+    return null;
+  }
+  return engine2;
+}
+
+// src/eval/runner.ts
+async function runEval(discovered, options2) {
+  const provider = discovered.evalConfig.provider ?? options2.defaultProvider;
+  const result = await options2.engine.run({
+    systemPrompt: discovered.systemPrompt,
+    tests: discovered.evalConfig.tests,
+    provider
+  });
+  const score = calculateScore(result.passed, result.total);
+  const grade = scoreToGrade(score);
+  return {
+    artifactId: discovered.artifactId,
+    elementName: discovered.elementName,
+    elementType: discovered.elementType,
+    passed: result.passed,
+    total: result.total,
+    score,
+    grade,
+    failures: result.failures
+  };
+}
+async function runAllEvals(discovered, options2) {
+  const results = [];
+  for (const [index, disc] of discovered.entries()) {
+    options2.onProgress?.(index, discovered.length, `${disc.elementType}/${disc.elementName}`);
+    const result = await runEval(disc, options2);
+    results.push(result);
+  }
+  options2.onProgress?.(discovered.length, discovered.length, "done");
+  return results;
+}
+
+// src/eval/display.ts
+function gradeColor(grade) {
+  switch (grade) {
+    case "A":
+    case "B":
+      return colors5.success;
+    case "C":
+    case "D":
+      return colors5.warning;
+    case "F":
+    default:
+      return colors5.error;
+  }
+}
+function formatDots(name2, maxWidth) {
+  const dotsNeeded = maxWidth - name2.length;
+  const dots = dotsNeeded > 2 ? " " + ".".repeat(dotsNeeded - 2) + " " : " ";
+  return colors5.dim(dots);
+}
+function displaySummary(summary) {
+  const byArtifact = new Map;
+  for (const result of summary.results) {
+    const existing = byArtifact.get(result.artifactId) ?? [];
+    existing.push(result);
+    byArtifact.set(result.artifactId, existing);
+  }
+  const maxNameWidth = Math.max(...summary.results.map((r) => `${r.elementType}/${r.elementName}`.length), 20);
+  for (const [artifactId, results] of byArtifact) {
+    log(colors5.bold(artifactId));
+    for (const result of results) {
+      const elementPath = `${result.elementType}/${result.elementName}`;
+      const dots = formatDots(elementPath, maxNameWidth);
+      const passText = `${result.passed}/${result.total} passed`;
+      const gradeText = gradeColor(result.grade)(result.grade);
+      log(`  ${elementPath}${dots}${passText}  ${gradeText}`);
+    }
+    newline();
+  }
+  const overallColor = gradeColor(summary.overallGrade);
+  log(`Overall: ${overallColor(summary.overallGrade)} (${summary.overallScore}/100)`);
+  if (summary.totalIssues > 0) {
+    log(`${summary.totalIssues} issue${summary.totalIssues === 1 ? "" : "s"} found`);
+    log(`Run ${colors5.highlight("grekt eval --details")} for more info`);
+  }
+}
+function displayDetails(summary) {
+  displaySummary(summary);
+  const failingResults = summary.results.filter((r) => r.failures.length > 0);
+  if (failingResults.length === 0)
+    return;
+  newline();
+  log(colors5.bold("Failures:"));
+  newline();
+  for (const result of failingResults) {
+    log(`  ${colors5.bold(`${result.elementType}/${result.elementName}`)} (${result.artifactId})`);
+    for (const failure of result.failures) {
+      log(`    ${symbols.error} ${failure.testDescription}`);
+      log(`      ${colors5.dim("assertion:")} ${failure.assertionType}`);
+      if (failure.expected) {
+        log(`      ${colors5.dim("expected:")} ${failure.expected}`);
+      }
+      if (failure.actual) {
+        log(`      ${colors5.dim("actual:")}   ${failure.actual}`);
+      }
+    }
+    newline();
+  }
+}
+function displayJson(summary) {
+  log(JSON.stringify(summary, null, 2));
+}
+
+// src/commands/eval.ts
+function buildFilter(options2) {
+  if (options2.skill)
+    return { elementName: options2.skill, elementType: "skills" };
+  if (options2.agent)
+    return { elementName: options2.agent, elementType: "agents" };
+  if (options2.command)
+    return { elementName: options2.command, elementType: "commands" };
+  return;
+}
+function requireProvider(projectRoot) {
+  const localConfig = getLocalConfig(projectRoot);
+  const providers = localConfig?.eval?.providers;
+  const firstProvider = providers?.[0];
+  if (firstProvider) {
+    return firstProvider;
+  }
+  error("No eval provider configured");
+  newline();
+  log("  Add a provider to .grekt/config.yaml:");
+  newline();
+  log(`    ${colors5.dim("eval:")}`);
+  log(`    ${colors5.dim("  providers:")}`);
+  log(`    ${colors5.dim("    - openai:gpt-4.1-mini")}`);
+  newline();
+  return process.exit(1);
+}
+var evalCommand = new Command("eval").description("Run eval tests against artifact elements (skills, agents, commands)").option("--artifact <name>", "Run evals for a specific artifact only").option("--skill <name>", "Run evals for a specific skill only").option("--agent <name>", "Run evals for a specific agent only").option("--command <name>", "Run evals for a specific command only").option("--details", "Show failure details").option("--report", "Open eval dashboard in browser").option("--format <format>", "Output format: text (default), json").action(async (options2) => {
+  const projectRoot = process.cwd();
+  requireInitialized(projectRoot);
+  const engine2 = await resolveEvalEngine();
+  if (!engine2)
+    process.exit(1);
+  if (options2.report) {
+    engine2.openReport?.();
+    return;
+  }
+  const defaultProvider = requireProvider(projectRoot);
+  const lockfile = getLockfile2(projectRoot);
+  const artifactIds = Object.keys(lockfile.artifacts);
+  if (artifactIds.length === 0) {
+    info("No artifacts installed");
+    process.exit(0);
+  }
+  const filter = buildFilter(options2);
+  const allDiscovered = [];
+  const allWarnings = [];
+  for (const artifactId of artifactIds) {
+    if (options2.artifact && artifactId !== options2.artifact)
+      continue;
+    const artifactDir = join35(projectRoot, ARTIFACTS_DIR, artifactId);
+    const result = discoverEvals(fs, { artifactDir, artifactId, filter });
+    allDiscovered.push(...result.evals);
+    allWarnings.push(...result.warnings);
+  }
+  for (const w of allWarnings) {
+    warning(w.message);
+  }
+  if (allDiscovered.length === 0) {
+    info("No eval files found");
+    if (!filter && !options2.artifact) {
+      info("Create a .eval.yaml file next to any skill, agent, or command");
+    }
+    process.exit(0);
+  }
+  const spin = spinner("Running evals...");
+  spin.start();
+  const results = await runAllEvals(allDiscovered, {
+    engine: engine2,
+    defaultProvider,
+    onProgress(completed, total, current) {
+      if (current === "done") {
+        spin.stop();
+      } else {
+        spin.text = `Running evals... (${completed + 1}/${total}) ${current}`;
+      }
+    }
+  });
+  const summary = summarizeResults(results);
+  newline();
+  if (options2.format === "json") {
+    displayJson(summary);
+  } else if (options2.details) {
+    displayDetails(summary);
+  } else {
+    displaySummary(summary);
+  }
+  if (summary.totalIssues > 0) {
+    process.exit(1);
+  }
+});
+
 // src/auth/oauth/oauth.ts
 import { spawn } from "child_process";
 import { randomUUID as randomUUID4 } from "crypto";
@@ -104406,7 +104973,7 @@ var whoamiCommand = new Command("whoami").description("Show current user").actio
 // package.json
 var package_default = {
   name: "@grekt/cli",
-  version: "6.42.0",
+  version: "6.43.0-beta.1",
   description: "AI tools versioned, synced, and shared across tools and teams",
   type: "module",
   bin: {
@@ -104441,7 +105008,7 @@ var package_default = {
   },
   dependencies: {
     "@aws-sdk/client-s3": "^3.971.0",
-    "@grekt/engine": "6.1.1",
+    "@grekt/engine": "6.2.0-beta.1",
     "@inquirer/prompts": "^7.2.0",
     "@supabase/supabase-js": "^2.91.0",
     chalk: "^5.4.1",
@@ -104475,13 +105042,13 @@ var package_default = {
 // src/update-check/update-check.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 var CACHE_FILENAME = ".update-check";
 var STALENESS_MS = 24 * 60 * 60 * 1000;
 var FETCH_TIMEOUT_MS = 1500;
 var GITHUB_RELEASES_URL = "https://api.github.com/repos/grekt-labs/cli/releases/latest";
 function getCachePath() {
-  return join35(homedir3(), ".grekt", CACHE_FILENAME);
+  return join36(homedir3(), ".grekt", CACHE_FILENAME);
 }
 function isOptedOut() {
   return process.env.GREKT_NO_UPDATE_CHECK === "1";
@@ -104500,7 +105067,7 @@ function readCache() {
 }
 function writeCache(cache2) {
   try {
-    const dir = join35(homedir3(), ".grekt");
+    const dir = join36(homedir3(), ".grekt");
     if (!existsSync2(dir)) {
       mkdirSync3(dir, { recursive: true });
     }
@@ -104614,6 +105181,7 @@ program2.addCommand(worktreeCommand);
 program2.addCommand(scanCommand);
 program2.addCommand(trustCommand);
 program2.addCommand(untrustCommand);
+program2.addCommand(evalCommand);
 setupUpdateCheck(package_default.version);
 try {
   await program2.parseAsync();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grekt/cli",
-  "version": "6.42.0",
+  "version": "6.43.0-beta.1",
   "description": "AI tools versioned, synced, and shared across tools and teams",
   "type": "module",
   "bin": {
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.971.0",
-    "@grekt/engine": "6.1.1",
+    "@grekt/engine": "6.2.0-beta.1",
     "@inquirer/prompts": "^7.2.0",
     "@supabase/supabase-js": "^2.91.0",
     "chalk": "^5.4.1",