@rcrsr/rill-cli 0.18.0 → 0.18.2

package/dist/check/rules/closures.js

@@ -59,14 +59,31 @@ export const CLOSURE_BARE_DOLLAR = {
  */
 function containsBareReference(node) {
     let found = false;
+    let scopeDepth = 0;
+    const scopeTypes = new Set([
+        'Closure',
+        'FilterExpr',
+        'MapExpr',
+        'EachExpr',
+    ]);
     const ctx = {};
     visitNode(node, ctx, {
         enter(n) {
+            if (scopeTypes.has(n.type)) {
+                scopeDepth++;
+                return;
+            }
+            if (scopeDepth > 0)
+                return;
             if (n.type === 'Variable' && n.isPipeVar) {
                 found = true;
             }
         },
-        exit() { },
+        exit(n) {
+            if (scopeTypes.has(n.type)) {
+                scopeDepth--;
+            }
+        },
     });
     return found;
 }
@@ -168,11 +185,15 @@ export const CLOSURE_LATE_BINDING = {
     validate(node, context) {
         const eachNode = node;
         const body = eachNode.body;
+        // For named parameter closures (|entry| { ... }), the body itself is a
+        // Closure. Look inside the inner block for nested closure creations,
+        // not the body closure itself.
+        const innerBody = body.type === 'Closure' ? body.body : body;
         // Check if body contains a closure creation
-        const hasClosureCreation = containsClosureCreation(body);
+        const hasClosureCreation = containsClosureCreation(innerBody);
         if (hasClosureCreation) {
             // Check if there's an explicit capture before the closure
-            const hasExplicitCapture = containsExplicitCapture(body);
+            const hasExplicitCapture = containsExplicitCapture(innerBody);
             if (!hasExplicitCapture) {
                 return [
                     {

package/dist/check/rules/collections.js

@@ -24,6 +24,23 @@ function containsBreak(node) {
     });
     return found;
 }
+/**
+ * Check if an AST subtree contains side-effecting operations.
+ * Detects HostCall (log, host functions) and ClosureCall ($fn(), $obj.method()).
+ */
+function containsSideEffects(node) {
+    let found = false;
+    const ctx = {};
+    visitNode(node, ctx, {
+        enter(n) {
+            if (n.type === 'HostCall' || n.type === 'ClosureCall') {
+                found = true;
+            }
+        },
+        exit() { },
+    });
+    return found;
+}
 /**
  * Check if a body is a simple method shorthand.
  * Body structure for .method shorthand is PostfixExpr with MethodCall as primary.
@@ -179,9 +196,13 @@ export const PREFER_MAP = {
                 return [];
             }
         }
-        // Simple heuristic: if body is pure (no side effects), suggest map
-        // For now, suggest map for simple transformations
-        // Full implementation would check for host calls, logging, etc.
+        // Check for side effects: host calls (log, etc.) and closure calls ($fn())
+        const innerBody = eachExpr.body.type === 'Closure'
+            ? eachExpr.body.body
+            : eachExpr.body;
+        if (containsSideEffects(innerBody)) {
+            return [];
+        }
         return [
             {
                 location: node.span.start,
@@ -189,7 +210,7 @@ export const PREFER_MAP = {
                 code: 'PREFER_MAP',
                 message: "Consider using 'map' instead of 'each' for pure transformations (no side effects)",
                 context: extractContextLine(node.span.start.line, context.source),
-                fix: null, // Could generate fix by replacing 'each' with 'map'
+                fix: null,
             },
         ];
     },

package/dist/check/rules/formatting.js

@@ -125,7 +125,6 @@ export const SPACING_BRACES = {
         const span = node.span;
         const lines = context.source.split('\n');
         const openLine = lines[span.start.line - 1] ?? '';
-        const closeLine = lines[span.end.line - 1] ?? '';
         // Check for opening brace without space after
         // Only examine the opening line (from the { onward)
         // Use ^ anchor to only check the block's opening brace, not string interpolation
@@ -141,11 +140,16 @@ export const SPACING_BRACES = {
             });
         }
         // Check for closing brace without space before
-        // span.end.column is 1-indexed and points AFTER the }, so:
-        // - } is at 0-index: span.end.column - 2
-        // - Character before } is at 0-index: span.end.column - 3
-        const charBeforeClose = closeLine[span.end.column - 3];
-        const isCloseOnOwnLine = /^\s*$/.test(closeLine.substring(0, span.end.column - 2));
+        // For Closure nodes with return type annotations, span.end extends past }
+        // to include the type annotation. Use body.span.end to find the actual }.
+        const closeSpan = node.type === 'Closure' ? node.body.span : span;
+        const closeEnd = closeSpan.end;
+        const closeLineActual = lines[closeEnd.line - 1] ?? '';
+        // closeEnd.column is 1-indexed and points AFTER the }, so:
+        // - } is at 0-index: closeEnd.column - 2
+        // - Character before } is at 0-index: closeEnd.column - 3
+        const charBeforeClose = closeLineActual[closeEnd.column - 3];
+        const isCloseOnOwnLine = /^\s*$/.test(closeLineActual.substring(0, closeEnd.column - 2));
         if (charBeforeClose && !/\s/.test(charBeforeClose) && !isCloseOnOwnLine) {
             diagnostics.push({
                 location: span.end,

package/dist/cli-run.js

@@ -11,7 +11,7 @@ import { parse, execute, createRuntimeContext, invokeCallable, isScriptCallable,
 import { resolveConfigPath, loadProject, parseMainField, introspectHandler, marshalCliArgs, ConfigError, } from '@rcrsr/rill-config';
 import { CLI_VERSION } from './cli-shared.js';
 import { explainError } from './cli-explain.js';
-import { runScript } from './run/runner.js';
+import { formatOutput, runScript } from './run/runner.js';
 // ============================================================
 // HELP TEXT
 // ============================================================
@@ -269,9 +269,16 @@ export async function main() {
             throw err;
         }
         ctx.pipeValue = handlerArgs;
+        // Map handler args to positional args in param order so marshalArgs
+        // can bind them to the closure's declared parameters.
+        // Omitted optional params stay undefined so closure defaults hydrate.
+        // pipeValue is kept for zero-param closures that access $ directly.
+        const positionalArgs = introspection.params.map((p) => (Object.prototype.hasOwnProperty.call(handlerArgs, p.name)
+            ? handlerArgs[p.name]
+            : undefined));
         let handlerResult;
         try {
-            handlerResult = await invokeCallable(handlerValue, [], ctx);
+            handlerResult = await invokeCallable(handlerValue, positionalArgs, ctx);
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
@@ -288,10 +295,13 @@ export async function main() {
                 }
             }
         }
-        if (typeof handlerResult === 'string' && handlerResult.length > 0) {
-            process.stdout.write(handlerResult + '\n');
+        if (handlerResult !== false &&
+            handlerResult !== '' &&
+            handlerResult !== undefined) {
+            const output = formatOutput(handlerResult, opts.format);
+            process.stdout.write(output + '\n');
         }
-        process.exit(0);
+        process.exit(handlerResult === false || handlerResult === '' ? 1 : 0);
     }
     // Module mode: main field in config is required
     if (mainField === undefined) {

package/dist/run/runner.d.ts

@@ -17,6 +17,7 @@ export interface RunResult {
  * - `module:alias` → `{dir}/index.rill`
  */
 export declare function buildModuleResolver(modulesConfig: Record<string, string>, configDir: string): SchemeResolver;
+export declare function formatOutput(value: RillValue, format: RunCliOptions['format']): string;
 /**
  * Run a rill script file with the given extension tree and config.
  */

package/dist/run/runner.js

@@ -59,7 +59,7 @@ function mapResultToRunResult(result, format) {
     const formatted = formatOutput(result, format);
     return { exitCode: 0, output: formatted };
 }
-function formatOutput(value, format) {
+export function formatOutput(value, format) {
     const native = toNative(value);
     if (format === 'json' || format === 'compact') {
         return JSON.stringify(native.value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rcrsr/rill-cli",
-  "version": "0.18.0",
+  "version": "0.18.2",
   "description": "CLI tools for the rill scripting language",
   "license": "MIT",
   "author": "Andre Bremer",
@@ -21,8 +21,8 @@
   "dependencies": {
     "dotenv": "^16.0.0",
     "yaml": "^2.8.2",
-    "@rcrsr/rill": "^0.18.0",
-    "@rcrsr/rill-config": "^0.18.0"
+    "@rcrsr/rill": "^0.18.2",
+    "@rcrsr/rill-config": "^0.18.1"
   },
   "files": [
     "dist"