lua-cli 3.21.0 → 3.22.0

package/dist/index.js

@@ -3012,6 +3012,18 @@ var init_skill_handler = __esm({
           return toolData;
         }).filter(Boolean);
         const sourceArchive = buildSourceArchive(archiveEntries);
+        let condition;
+        let conditionS3Hash;
+        if (skill.hasCondition) {
+          const skillCode = loadArtifact(skill, projectPath);
+          if (bundleAccumulator) {
+            const rawGzip = compressForPushRaw(skillCode);
+            conditionS3Hash = hashBundle(rawGzip);
+            bundleAccumulator.set(conditionS3Hash, rawGzip);
+          } else {
+            condition = compressForPush(skillCode);
+          }
+        }
         return {
           name: skill.name,
           description: skill.description,
@@ -3020,6 +3032,12 @@ var init_skill_handler = __esm({
             context: skill.context
           } : {},
           tools,
+          ...condition ? {
+            condition
+          } : {},
+          ...conditionS3Hash ? {
+            conditionS3Hash
+          } : {},
           ...sourceArchive ? {
             sourceArchive,
             archiveSchemaVersion: SOURCE_ARCHIVE_SCHEMA_VERSION
@@ -6934,14 +6952,24 @@ var init_skill_plugin = __esm({
       //   2. Residual super-edge cases — `stripSuperCallsInConstructors` covers
       //      top-level `super(...)` only; `super.method()` mid-constructor and
       //      `field = super.x` survive a strip and explode at runtime.
-      // MAINTENANCE: this whitelist also assumes skills are JSON-only artifacts (via
-      // `buildArtifact`). If skills ever migrate to bundled JS, this drop will silently
-      // lose `tools` from skill bundles — re-evaluate.
+      // MAINTENANCE: a skill WITH a `condition` is bundled through esbuild (see
+      // `buildArtifact`), so every field the runtime needs off the bundle must be
+      // listed here or it is silently dropped. `tools` stays out by design — the
+      // compiler resolves tool refs separately via `resolveArrayRefs`. The
+      // whitelist only governs config literals; `dropClassMembers` is the same
+      // drop for the class-definition shape, where a `tools = [...]` field or a
+      // `this.addTool(...)` call would otherwise keep the tool imports live.
       crossFileRewrite = {
         fields: [
           "name",
           "description",
-          "context"
+          "context",
+          "condition"
+        ],
+        dropClassMembers: [
+          "tools",
+          "addTool",
+          "addTools"
         ]
       };
       supportsClassDefinition = true;
@@ -6998,7 +7026,12 @@ var init_skill_plugin = __esm({
             pattern: "class-definition",
             context,
             toolRefs,
-            toolRefSourcePaths: Object.keys(toolRefSourcePaths).length > 0 ? toolRefSourcePaths : void 0
+            toolRefSourcePaths: Object.keys(toolRefSourcePaths).length > 0 ? toolRefSourcePaths : void 0,
+            // Emitted only when present so a condition-less skill's JSON artifact
+            // stays byte-identical to pre-feature output.
+            ...findClassMember(classDecl, "condition", "either") !== void 0 ? {
+              hasCondition: true
+            } : {}
           }
         };
       }
@@ -7054,7 +7087,10 @@ var init_skill_plugin = __esm({
             pattern,
             context,
             toolRefs,
-            toolRefSourcePaths: Object.keys(toolRefSourcePaths).length > 0 ? toolRefSourcePaths : void 0
+            toolRefSourcePaths: Object.keys(toolRefSourcePaths).length > 0 ? toolRefSourcePaths : void 0,
+            ...config.getProperty("condition") !== void 0 ? {
+              hasCondition: true
+            } : {}
           }
         };
       }
@@ -7199,13 +7235,19 @@ var init_skill_plugin = __esm({
         return rest;
       }
       /**
-      * Skills have no executable code and their artifact is never loaded at
-      * runtime (see `SkillHandler.prepareForPush` — it loads tool artifacts
-      * but never the skill's own). Emit a JSON metadata artifact instead of
-      * running esbuild on `new LuaSkill({...})`, which would otherwise bundle
-      * a non-executable shell (LuaSkill is stripped as an external import).
+      * A skill without a `condition` has no executable code and its artifact is
+      * never loaded at runtime (see `SkillHandler.prepareForPush` — it loads tool
+      * artifacts, plus the skill's own only when it has a condition). Emit a JSON
+      * metadata artifact instead of running esbuild on `new LuaSkill({...})`,
+      * which would otherwise bundle a non-executable shell (LuaSkill is stripped
+      * as an external import).
+      *
+      * A skill WITH a condition returns undefined to fall through to the standard
+      * `generateEntryPoint → bundler.bundle → postProcess` esbuild path, same as
+      * `AgentPlugin` with a model resolver.
       */
       async buildArtifact(metadata) {
+        if (metadata.metadata.hasCondition) return void 0;
         const code = JSON.stringify({
           kind: metadata.kind,
           name: metadata.name,
@@ -7222,6 +7264,32 @@ var init_skill_plugin = __esm({
         };
       }
       /**
+      * Project the class instance onto the skill primitive shape. Binds
+      * `condition` to the instance so `this` references resolve correctly,
+      * mirroring `ToolPlugin`. Skills have no `execute`, so the base shape
+      * doesn't apply.
+      */
+      getClassDefinitionPrimitiveShape(metadata) {
+        return `{
+    kind: 'skill',
+    name: __lua_instance__.name ?? ${JSON.stringify(metadata.name)},
+    description: __lua_instance__.description ?? ${JSON.stringify(metadata.description)},
+    context: __lua_instance__.context,
+    condition: typeof __lua_instance__.condition === 'function' ? __lua_instance__.condition.bind(__lua_instance__) : undefined,
+  }`;
+      }
+      /**
+      * Runtime validation — a skill only reaches the bundled path when it
+      * declares a condition, so the bundle must expose a callable one.
+      */
+      getRuntimeValidation(metadata) {
+        if (!metadata.metadata.hasCondition) return "";
+        return `
+  if (typeof primitive.primitive?.condition !== 'function') {
+    throw new Error('[Lua] Invalid skill artifact: condition is not a function');
+  }`;
+      }
+      /**
       * Resolve tool references from this skill.
       *
       * Skills reference tools by class/variable name. This method:
@@ -7305,7 +7373,8 @@ var init_skill_plugin = __esm({
         return {
           ...this.baseManifestFields(compiled),
           context: skillMetadata.context,
-          tools: toolNames
+          tools: toolNames,
+          hasCondition: skillMetadata.hasCondition || false
         };
       }
     };
@@ -8121,7 +8190,7 @@ function rewriteCrossFileCallsInSourceFile(sf, specs, sdkBaseClassNames) {
     node.replaceWithText(buildBareObjectLiteral(spec, objArg));
     progressed = true;
   }
-  stripSdkExtendsClauses(sf, sdkBaseClassNames, aliasMap);
+  stripSdkExtendsClauses(sf, sdkBaseClassNames, aliasMap, specs);
 }
 function warnUnsupportedNamespaceImports(sf) {
   for (const imp of sf.getImportDeclarations()) {
@@ -8141,20 +8210,29 @@ function warnUnsupportedNamespaceImports(sf) {
     }));
   }
 }
-function stripSdkExtendsClauses(sf, sdkBaseClassNames, aliasMap) {
-  const matchesSdkClass = /* @__PURE__ */ __name((text) => {
+function stripSdkExtendsClauses(sf, sdkBaseClassNames, aliasMap, specs) {
+  const matchSdkClass = /* @__PURE__ */ __name((text) => {
     const canonical = aliasMap.get(text) ?? text;
-    return sdkBaseClassNames.has(canonical);
-  }, "matchesSdkClass");
+    return sdkBaseClassNames.has(canonical) ? canonical : void 0;
+  }, "matchSdkClass");
+  const dropNamesFor = /* @__PURE__ */ __name((canonical) => {
+    const spec = specs.find((s) => s.classNames.includes(canonical));
+    if (!spec?.dropClassMembers?.length) return void 0;
+    return new Set(spec.dropClassMembers);
+  }, "dropNamesFor");
+  const strip = /* @__PURE__ */ __name((classNode, canonical) => {
+    classNode.removeExtends();
+    const dropNames = dropNamesFor(canonical);
+    if (dropNames) stripDroppedClassMembers(classNode, dropNames);
+    stripSuperCallsInConstructors(classNode);
+  }, "strip");
   for (const classDecl of sf.getClasses()) {
     const ext = classDecl.getExtends();
     if (!ext) continue;
     const expr = ext.getExpression();
     if (!Node15.isIdentifier(expr)) continue;
-    if (matchesSdkClass(expr.getText())) {
-      classDecl.removeExtends();
-      stripSuperCallsInConstructors(classDecl);
-    }
+    const canonical = matchSdkClass(expr.getText());
+    if (canonical) strip(classDecl, canonical);
   }
   sf.forEachDescendant((n) => {
     if (!Node15.isClassExpression(n)) return;
@@ -8162,11 +8240,31 @@ function stripSdkExtendsClauses(sf, sdkBaseClassNames, aliasMap) {
     if (!ext) return;
     const expr = ext.getExpression();
     if (!Node15.isIdentifier(expr)) return;
-    if (matchesSdkClass(expr.getText())) {
-      n.removeExtends();
-      stripSuperCallsInConstructors(n);
-    }
+    const canonical = matchSdkClass(expr.getText());
+    if (canonical) strip(n, canonical);
+  });
+}
+function stripDroppedClassMembers(classNode, dropNames) {
+  for (const prop of classNode.getProperties()) {
+    if (dropNames.has(prop.getName())) prop.remove();
+  }
+  const statements = [];
+  classNode.forEachDescendant((n) => {
+    if (!Node15.isExpressionStatement(n)) return;
+    if (isThisRootedCallTo(n.getExpression(), dropNames)) statements.push(n);
   });
+  for (const stmt of statements) stmt.remove();
+}
+function isThisRootedCallTo(expression, dropNames) {
+  let current = expression;
+  let matched = false;
+  while (Node15.isCallExpression(current)) {
+    const callee = current.getExpression();
+    if (!Node15.isPropertyAccessExpression(callee)) return false;
+    if (dropNames.has(callee.getName())) matched = true;
+    current = callee.getExpression();
+  }
+  return matched && current.getKind() === ts3.SyntaxKind.ThisKeyword;
 }
 function stripSuperCallsInConstructors(classNode) {
   for (const ctor of classNode.getConstructors()) {
@@ -8273,6 +8371,8 @@ function buildBareObjectLiteral(spec, arg) {
       if (init) parts.push(`${f}: ${init.getText()}`);
     } else if (prop && Node15.isShorthandPropertyAssignment(prop)) {
       parts.push(`${f}: ${prop.getName()}`);
+    } else if (prop && Node15.isMethodDeclaration(prop)) {
+      parts.push(prop.getText());
     }
   }
   return `{ ${parts.join(", ")} }`;
@@ -8342,6 +8442,8 @@ var init_primitive_rewrite = __esm({
     __name(rewriteCrossFileCallsInSourceFile, "rewriteCrossFileCallsInSourceFile");
     __name(warnUnsupportedNamespaceImports, "warnUnsupportedNamespaceImports");
     __name(stripSdkExtendsClauses, "stripSdkExtendsClauses");
+    __name(stripDroppedClassMembers, "stripDroppedClassMembers");
+    __name(isThisRootedCallTo, "isThisRootedCallTo");
     __name(stripSuperCallsInConstructors, "stripSuperCallsInConstructors");
     __name(warnRemainingSuperReferences, "warnRemainingSuperReferences");
     __name(buildSdkAliasMap, "buildSdkAliasMap");
@@ -8364,16 +8466,19 @@ function buildCrossFileSpecs(plugins = pluginRegistry.getAll()) {
       ...plugin.legacyClassNames
     ];
     const defineFunction = plugin.defineFunction || void 0;
+    const dropClassMembers = plugin.crossFileRewrite.dropClassMembers;
     if ("copyAllFields" in plugin.crossFileRewrite && plugin.crossFileRewrite.copyAllFields) {
       specs.push({
         classNames,
         defineFunction,
+        dropClassMembers,
         mode: "copyAllFields"
       });
     } else if ("fields" in plugin.crossFileRewrite) {
       specs.push({
         classNames,
         defineFunction,
+        dropClassMembers,
         mode: "whitelist",
         fields: plugin.crossFileRewrite.fields
       });
@@ -20203,6 +20308,22 @@ function buildSandboxProcess(opts) {
   const nextTickFn = /* @__PURE__ */ __name4((cb, ...args2) => {
     process.nextTick(cb, ...args2);
   }, "nextTickFn");
+  const buildStdioStub = /* @__PURE__ */ __name4((fd) => {
+    const stub = {
+      fd,
+      isTTY: false,
+      write: /* @__PURE__ */ __name4(() => true, "write"),
+      end: /* @__PURE__ */ __name4(() => stub, "end"),
+      on: /* @__PURE__ */ __name4(() => stub, "on"),
+      once: /* @__PURE__ */ __name4(() => stub, "once"),
+      removeListener: /* @__PURE__ */ __name4(() => stub, "removeListener"),
+      cork: /* @__PURE__ */ __name4(() => {
+      }, "cork"),
+      uncork: /* @__PURE__ */ __name4(() => {
+      }, "uncork")
+    };
+    return stub;
+  }, "buildStdioStub");
   const proc = {
     env: opts.envVars,
     version: process.version,
@@ -20212,6 +20333,8 @@ function buildSandboxProcess(opts) {
     platform: process.platform,
     arch: process.arch,
     pid: process.pid,
+    stdout: buildStdioStub(1),
+    stderr: buildStdioStub(2),
     nextTick: nextTickFn,
     hrtime: hrtimeFn,
     // Lie — don't leak host filesystem layout. Skills should not depend on