langflower 0.1.3 → 0.2.0

package/dist/{chunk-WV2YWHOC.js → chunk-26UB55E5.js}

@@ -194,6 +194,21 @@ var resolveTypesRelative = (packageRoot, relative) => {
   const absolute = path3.resolve(packageRoot, relative);
   return fs2.existsSync(absolute) ? absolute : void 0;
 };
+var hostPeerSubpath = (specifier) => {
+  for (const name of HOST_PEER_PACKAGES) {
+    if (specifier.startsWith(`${name}/`)) {
+      return specifier.slice(name.length + 1);
+    }
+  }
+  return void 0;
+};
+var typesFromExportsSubpath = (exportsField, subpath) => {
+  const record = asRecord(exportsField);
+  if (record === void 0) {
+    return void 0;
+  }
+  return typesFromExportTarget(record[`./${subpath}`]);
+};
 var resolveHostPackageTypes = (specifier) => {
   const entry = resolvePackageEntry(specifier);
   if (entry === void 0) {
@@ -207,13 +222,17 @@ var resolveHostPackageTypes = (specifier) => {
   if (pkg === void 0) {
     return void 0;
   }
-  const fromExports = typesFromExportsField(pkg.exports);
+  const subpath = hostPeerSubpath(specifier);
+  const fromExports = subpath === void 0 ? typesFromExportsField(pkg.exports) : typesFromExportsSubpath(pkg.exports, subpath);
   if (fromExports !== void 0) {
     const resolved = resolveTypesRelative(packageRoot, fromExports);
     if (resolved !== void 0) {
       return resolved;
     }
   }
+  if (subpath !== void 0) {
+    return void 0;
+  }
   const fromTypes = pkg.types ?? pkg.typings;
   if (typeof fromTypes === "string") {
     const resolved = resolveTypesRelative(packageRoot, fromTypes);
@@ -235,12 +254,33 @@ var hostRuntimeStamp = () => HOST_PEER_PACKAGES.map((name) => {
 }).join(";");
 var hostPathMappings = () => {
   const mappings = {};
-  for (const name of HOST_PEER_PACKAGES) {
-    const typesPath = resolveHostPackageTypes(name);
+  const add = (specifier) => {
+    const typesPath = resolveHostPackageTypes(specifier);
     if (typesPath === void 0) {
+      return;
+    }
+    mappings[specifier] = [toPosix(typesPath)];
+  };
+  for (const name of HOST_PEER_PACKAGES) {
+    add(name);
+    const entry = resolvePackageEntry(name);
+    if (entry === void 0) {
+      continue;
+    }
+    const packageRoot = findPackageRoot(entry);
+    if (packageRoot === void 0) {
       continue;
     }
-    mappings[name] = [toPosix(typesPath)];
+    const exportsField = asRecord(readPackageJson(packageRoot)?.exports);
+    if (exportsField === void 0) {
+      continue;
+    }
+    for (const key of Object.keys(exportsField)) {
+      if (key === "." || !key.startsWith("./")) {
+        continue;
+      }
+      add(`${name}/${key.slice(2)}`);
+    }
   }
   return mappings;
 };

package/dist/{chunk-AO33IM2J.js → chunk-2LE3E2QP.js}

@@ -2,8 +2,9 @@ import { createRequire as __lfCreateRequire } from 'node:module';
 const require = __lfCreateRequire(import.meta.url);
 
 import {
+  DEFAULT_PERMISSION_CONFIG,
   createProjectHarness
-} from "./chunk-NIRPHJLO.js";
+} from "./chunk-3Z7Q6SQ5.js";
 import "./chunk-EAZMCX37.js";
 
 // packages/cli/dist/eval-command.js
@@ -97,18 +98,6 @@ var loadReplayMap = async (replayPath) => {
 // packages/eval/dist/run-eval-suite.js
 import path2 from "node:path";
 
-// packages/eval/dist/load-skill-via-read.js
-var loadSkillViaRead = async (harness, skillPath) => {
-  const result = await harness.invoke({
-    toolId: "read",
-    args: { path: skillPath }
-  });
-  if (!result.ok) {
-    throw new Error(`failed to read skill via harness read (${skillPath}): ${result.text}`);
-  }
-  return result.text;
-};
-
 // packages/eval/dist/score-case.js
 var scoreCase = (actual, expected, scorer) => {
   const a = actual.trim();
@@ -122,15 +111,29 @@ var scoreCase = (actual, expected, scorer) => {
 };
 
 // packages/eval/dist/run-eval-suite.js
-var allowReadPermission = {
+var skillReadPermission = {
+  ...DEFAULT_PERMISSION_CONFIG,
   read: { "*": "allow" },
-  glob: { "*": "allow" },
-  grep: { "*": "allow" },
+  glob: { "*": "deny" },
+  grep: { "*": "deny" },
   edit: { "*": "deny" },
   write: { "*": "deny" },
   create: { "*": "deny" },
   delete: { "*": "deny" },
-  bash: { "*": "deny" }
+  move: { "*": "deny" },
+  sleep: { "*": "deny" },
+  bash: { "*": "deny" },
+  ask_user: { "*": "deny" }
+};
+var loadSkillViaRead = async (harness, skillPath) => {
+  const result = await harness.invoke({
+    toolId: "read",
+    args: { path: skillPath }
+  });
+  if (!result.ok) {
+    throw new Error(`failed to read skill via harness read (${skillPath}): ${result.text}`);
+  }
+  return result.text;
 };
 var meanScore = (scores) => {
   if (scores.length === 0) {
@@ -143,19 +146,17 @@ var runEvalSuite = async (options) => {
   const packDir = path2.resolve(options.packDir);
   const projectRoot = path2.resolve(options.projectRoot ?? packDir);
   const pack = await loadEvalPack(packDir);
-  const harness = options.harness ?? (pack.skillPath === void 0 ? null : createProjectHarness({
+  const skillMarkdown = pack.skillPath === void 0 ? null : await loadSkillViaRead(createProjectHarness({
     projectRoot,
-    permission: allowReadPermission
-  }));
-  const skillMarkdown = pack.skillPath === void 0 || harness === null ? null : await loadSkillViaRead(harness, pack.skillPath);
+    permission: skillReadPermission
+  }), pack.skillPath);
   const caseResults = [];
   for (const evalCase of pack.cases) {
     const actual = await options.runCase({
       pack,
       case: evalCase,
       skillMarkdown,
-      projectRoot,
-      harness
+      projectRoot
     });
     const scorer = evalCase.scorer ?? pack.scorer;
     const score = scoreCase(actual, evalCase.expected, scorer);