@rcrsr/rill 0.1.0 → 0.2.0

package/dist/check/rules/flow.js

@@ -0,0 +1,206 @@
+/**
+ * Flow and Capture Rules
+ * Enforces conventions for capture placement and flow patterns.
+ */
+import { extractContextLine } from './helpers.js';
+// ============================================================
+// HELPER FUNCTIONS
+// ============================================================
+/**
+ * Check if a node is a capture node.
+ */
+function isCaptureNode(node) {
+    return (typeof node === 'object' &&
+        node !== null &&
+        'type' in node &&
+        node.type === 'Capture');
+}
+/**
+ * Check if a node contains a variable reference.
+ * For $ (pipe variable), checks for isPipeVar: true.
+ * For named variables, checks for the variable name.
+ * This is a simplified check - a full implementation would traverse the AST.
+ */
+function referencesVariable(node, varName) {
+    if (!node)
+        return false;
+    // Convert node to string representation and check for variable usage
+    // This is a heuristic - proper implementation would need AST traversal
+    const nodeStr = JSON.stringify(node);
+    if (varName === '$') {
+        // Pipe variable has isPipeVar: true
+        return nodeStr.includes('"isPipeVar":true');
+    }
+    else {
+        // Named variable
+        return nodeStr.includes(`"name":"${varName}"`);
+    }
+}
+/**
+ * Get the primary expression from a PipeChain's head.
+ * ArithHead can be BinaryExprNode, UnaryExprNode, or PostfixExprNode.
+ */
+function getPrimaryFromHead(chain) {
+    const head = chain.head;
+    // If head is PostfixExprNode, get its primary
+    if (head.type === 'PostfixExpr') {
+        return head.primary;
+    }
+    // For BinaryExprNode or UnaryExprNode, we can't easily get a single primary
+    return null;
+}
+// ============================================================
+// CAPTURE_INLINE_CHAIN RULE
+// ============================================================
+/**
+ * Validates that captures use inline syntax when continuing the chain.
+ *
+ * Detects separate capture followed by variable usage:
+ *   prompt("Read file") :> $raw
+ *   $raw -> log
+ *
+ * Suggests inline capture:
+ *   prompt("Read file") :> $raw -> log
+ *
+ * This is an informational rule - both patterns work, but inline is clearer.
+ *
+ * References:
+ * - docs/16_conventions.md:56-74
+ */
+export const CAPTURE_INLINE_CHAIN = {
+    code: 'CAPTURE_INLINE_CHAIN',
+    category: 'flow',
+    severity: 'info',
+    nodeTypes: ['Statement'],
+    validate(node, context) {
+        const statement = node;
+        const chain = statement.expression;
+        // Check if this chain ends with a capture
+        // Captures can be in terminator OR as the last pipe element
+        let captureNode = null;
+        if (chain.terminator && isCaptureNode(chain.terminator)) {
+            captureNode = chain.terminator;
+        }
+        else if (chain.pipes.length > 0) {
+            const lastPipe = chain.pipes[chain.pipes.length - 1];
+            if (lastPipe && isCaptureNode(lastPipe)) {
+                captureNode = lastPipe;
+            }
+        }
+        if (!captureNode) {
+            return [];
+        }
+        const capturedVarName = captureNode.name;
+        // Get all statements from the script
+        const statements = context.ast.statements;
+        const currentIndex = statements.indexOf(statement);
+        if (currentIndex === -1 || currentIndex === statements.length - 1) {
+            return [];
+        }
+        const nextStatement = statements[currentIndex + 1];
+        if (!nextStatement)
+            return [];
+        // Check if next statement is a Statement wrapping a PipeChain
+        if (nextStatement.type !== 'Statement') {
+            return [];
+        }
+        const nextStmt = nextStatement;
+        const nextChain = nextStmt.expression;
+        // Check if the head of the next chain is the captured variable
+        const headPrimary = getPrimaryFromHead(nextChain);
+        if (headPrimary &&
+            headPrimary.type === 'Variable' &&
+            'name' in headPrimary &&
+            headPrimary.name === capturedVarName) {
+            // Found pattern: capture on one line, immediate usage on next line
+            return [
+                {
+                    location: captureNode.span.start,
+                    severity: 'info',
+                    code: 'CAPTURE_INLINE_CHAIN',
+                    message: `Consider inline capture: ':> $${capturedVarName} -> ...' instead of separate statements`,
+                    context: extractContextLine(captureNode.span.start.line, context.source),
+                    fix: null, // Complex fix - requires merging statements
+                },
+            ];
+        }
+        return [];
+    },
+};
+// ============================================================
+// CAPTURE_BEFORE_BRANCH RULE
+// ============================================================
+/**
+ * Validates that values used in multiple branches are captured before the conditional.
+ *
+ * Detects conditionals where a function call or expression appears in multiple branches:
+ *   checkStatus() -> .contains("OK") ? {
+ *     "Success: {checkStatus()}"
+ *   } ! {
+ *     "Failed: {checkStatus()}"
+ *   }
+ *
+ * Suggests capturing before branching:
+ *   checkStatus() :> $result
+ *   $result -> .contains("OK") ? {
+ *     "Success: {$result}"
+ *   } ! {
+ *     "Failed: {$result}"
+ *   }
+ *
+ * This is an informational rule - detects potential inefficiency and clarity issues.
+ *
+ * References:
+ * - docs/16_conventions.md:76-88
+ */
+export const CAPTURE_BEFORE_BRANCH = {
+    code: 'CAPTURE_BEFORE_BRANCH',
+    category: 'flow',
+    severity: 'info',
+    nodeTypes: ['Conditional'],
+    validate(node, context) {
+        const conditional = node;
+        // Check if both branches exist
+        if (!conditional.elseBranch) {
+            return [];
+        }
+        // For piped conditionals (input is null), we can still suggest capturing
+        // For explicit conditionals, check if input is complex
+        const inputExpr = conditional.input;
+        // If input exists and is already a simple variable, no need to capture
+        if (inputExpr && inputExpr.type === 'PipeChain') {
+            const headPrimary = getPrimaryFromHead(inputExpr);
+            if (headPrimary &&
+                headPrimary.type === 'Variable' &&
+                inputExpr.pipes.length === 0 &&
+                !inputExpr.terminator) {
+                return [];
+            }
+        }
+        // Look for patterns where the input value might be used in both branches
+        // This is heuristic-based: we check if there's a $ reference in both branches
+        // which would be the piped value from the conditional input
+        const thenReferences = referencesVariable(conditional.thenBranch, '$');
+        // elseBranch can be BodyNode or ConditionalNode (for else-if chains)
+        const elseBranch = conditional.elseBranch;
+        const elseReferences = elseBranch && elseBranch.type !== 'Conditional'
+            ? referencesVariable(elseBranch, '$')
+            : false;
+        // If $ is used in both branches, suggest capturing the input value
+        // This makes it available in both branches with a clear name
+        if (thenReferences && elseReferences) {
+            return [
+                {
+                    location: conditional.span.start,
+                    severity: 'info',
+                    code: 'CAPTURE_BEFORE_BRANCH',
+                    message: 'Consider capturing value before conditional when used in multiple branches',
+                    context: extractContextLine(conditional.span.start.line, context.source),
+                    fix: null, // Complex fix - requires AST restructuring
+                },
+            ];
+        }
+        return [];
+    },
+};
+//# sourceMappingURL=flow.js.map

package/dist/check/rules/flow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.js","sourceRoot":"","sources":["../../../src/check/rules/flow.ts"],"names":[],"mappings":"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"}

package/dist/check/rules/formatting.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Formatting Rules
+ * Enforces style conventions from docs/16_conventions.md:465-662.
+ */
+import type { ValidationRule } from '../types.js';
+/**
+ * Enforces space on both sides of operators.
+ * Operators like +, -, ->, :>, ==, etc. should have spaces on both sides.
+ *
+ * Detection:
+ * - Extract operator text from source using source spans
+ * - Check if space exists before/after operator
+ *
+ * References:
+ * - docs/16_conventions.md:467-482
+ */
+export declare const SPACING_OPERATOR: ValidationRule;
+/**
+ * Enforces space after { and before } in blocks.
+ * Braces for blocks, closures, etc. should have internal spacing.
+ *
+ * Detection:
+ * - Extract brace content from source
+ * - Check if opening { has space after, closing } has space before
+ *
+ * References:
+ * - docs/16_conventions.md:497-508
+ */
+export declare const SPACING_BRACES: ValidationRule;
+/**
+ * Enforces no inner spaces for indexing brackets.
+ * Array/dict indexing should use $list[0] not $list[ 0 ].
+ *
+ * Detection:
+ * - PostfixExpr nodes with index access
+ * - Check for spaces inside brackets
+ *
+ * References:
+ * - docs/16_conventions.md:526-535
+ */
+export declare const SPACING_BRACKETS: ValidationRule;
+/**
+ * Enforces no space before pipe, space after in closures.
+ * Closure parameters: |x| not | x |.
+ *
+ * Detection:
+ * - Extract closure parameter section from source
+ * - Check spacing around pipes
+ *
+ * References:
+ * - docs/16_conventions.md:549-560
+ */
+export declare const SPACING_CLOSURE: ValidationRule;
+/**
+ * Enforces 2-space indent for continued lines.
+ * Pipe chains should indent continuation lines by 2 spaces.
+ *
+ * Detection:
+ * - Multi-line pipe chains
+ * - Check indentation of continuation lines
+ *
+ * References:
+ * - docs/16_conventions.md:636-662
+ */
+export declare const INDENT_CONTINUATION: ValidationRule;
+/**
+ * Detect explicit $.method() patterns replaceable with .method.
+ *
+ * Flags method calls where the receiver is a bare $ (pipe variable).
+ * The implicit form .method is preferred when $ represents the current
+ * piped value (e.g., in blocks, closures, conditionals).
+ *
+ * Detection:
+ * - MethodCallNode with non-null receiverSpan
+ * - Receiver is bare $ (zero-width or single-char span)
+ * - Method call is first in chain (receiverSpan.end.offset <= 1)
+ *
+ * Note: Cannot use isBareReference() helper here because MethodCallNode.receiverSpan
+ * is a SourceSpan (position range), not an ExpressionNode. The helper requires
+ * an AST node to traverse. Instead, we detect bare $ by checking:
+ * 1. receiverSpan is zero-width (start == end) or single-char
+ * 2. Character at offset is '$'
+ * 3. Next character is '.' (not a variable name continuation)
+ *
+ * Examples:
+ * - $.upper() -> .upper
+ * - $.len -> .len
+ * - $.trim().upper() -> First method flagged, second is chained (not bare $)
+ *
+ * Not flagged:
+ * - .upper (receiverSpan is null)
+ * - $var.method() (receiverSpan is not bare $)
+ * - $.trim().upper() second method (receiverSpan covers $.trim())
+ *
+ * References:
+ * - docs/16_conventions.md:587-598
+ */
+export declare const IMPLICIT_DOLLAR_METHOD: ValidationRule;
+/**
+ * Prefer foo over foo($) for global function calls.
+ * When single argument is bare $, prefer implicit form.
+ *
+ * Detection:
+ * - HostCall with single argument that is bare $
+ *
+ * References:
+ * - docs/16_conventions.md:599-607
+ */
+export declare const IMPLICIT_DOLLAR_FUNCTION: ValidationRule;
+/**
+ * Prefer $fn over $fn($) for closure invocation.
+ * When single argument is bare $, prefer implicit form.
+ *
+ * Detection:
+ * - ClosureCall with single argument that is bare $
+ *
+ * References:
+ * - docs/16_conventions.md:608-615
+ */
+export declare const IMPLICIT_DOLLAR_CLOSURE: ValidationRule;
+/**
+ * Warns on capture-only-to-continue patterns.
+ * Capturing a value just to use it immediately in the next line is unnecessary.
+ *
+ * Detection:
+ * - Capture node followed by immediate use of that variable only
+ * - Variable not referenced later in the script
+ *
+ * References:
+ * - docs/16_conventions.md:617-634
+ */
+export declare const THROWAWAY_CAPTURE: ValidationRule;
+//# sourceMappingURL=formatting.d.ts.map

package/dist/check/rules/formatting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatting.d.ts","sourceRoot":"","sources":["../../../src/check/rules/formatting.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,cAAc,EAKf,MAAM,aAAa,CAAC;AAqBrB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,EAAE,cA0E9B,CAAC;AA6CF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,EAAE,cAuC5B,CAAC;AAMF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAiI9B,CAAC;AAMF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,EAAE,cAgD7B,CAAC;AAMF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,EAAE,cAuDjC,CAAC;AAMF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,sBAAsB,EAAE,cA4DpC,CAAC;AAMF;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,EAAE,cA4CtC,CAAC;AAMF;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,EAAE,cAkDrC,CAAC;AAMF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAW/B,CAAC"}