@nudojs/cli 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # nudo
 
+## 0.2.0
+
+### Minor Changes
+
+- 6c38283: docs and ci
+- 9f7f819: fix pkg info
+- c175f71: version
+
+### Patch Changes
+
+- Updated dependencies [6c38283]
+- Updated dependencies [9f7f819]
+- Updated dependencies [c175f71]
+  - @nudojs/core@0.2.0
+  - @nudojs/parser@0.2.0
+
 ## 0.1.0
 
 ### Minor Changes

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nudo Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/{chunk-JW3RMCNY.js → chunk-LGWVGEMB.js}

@@ -36,7 +36,9 @@ import {
   narrowType,
   subtractType,
   getPrimitiveTypeOf,
-  typeValueEquals
+  typeValueEquals,
+  isSubtypeOf,
+  createRange
 } from "@nudojs/core";
 function narrow(test, env) {
   if (test.type === "BinaryExpression" && test.operator === "===" && isTypeofExpr(test.left) && test.right.type === "StringLiteral") {
@@ -82,6 +84,19 @@ function narrow(test, env) {
   if (test.type === "BinaryExpression" && test.operator === "instanceof" && test.left.type === "Identifier" && test.right.type === "Identifier") {
     return narrowByInstanceof(test.left.name, test.right.name, env);
   }
+  if (test.type === "BinaryExpression" && (test.operator === ">=" || test.operator === ">" || test.operator === "<=" || test.operator === "<") && test.left.type === "Identifier" && isLiteralNode(test.right)) {
+    const litVal = getLiteralValue(test.right);
+    if (litVal.kind === "literal" && typeof litVal.value === "number") {
+      return narrowByComparison(test.left.name, test.operator, litVal.value, env);
+    }
+  }
+  if (test.type === "BinaryExpression" && (test.operator === ">=" || test.operator === ">" || test.operator === "<=" || test.operator === "<") && isLiteralNode(test.left) && test.right.type === "Identifier") {
+    const litVal = getLiteralValue(test.left);
+    if (litVal.kind === "literal" && typeof litVal.value === "number") {
+      const flipped = { ">=": "<=", ">": "<", "<=": ">=", "<": ">" };
+      return narrowByComparison(test.right.name, flipped[test.operator], litVal.value, env);
+    }
+  }
   if (test.type === "UnaryExpression" && test.operator === "!") {
     const [trueEnv, falseEnv] = narrow(test.argument, env);
     return [falseEnv, trueEnv];
@@ -183,17 +198,32 @@ function narrowByStrictEqual(varName, literalTV, env) {
   falseEnv.bind(varName, excluded.kind === "never" ? current : excluded);
   return [trueEnv, falseEnv];
 }
+function narrowByComparison(varName, op, value, env) {
+  const current = env.lookup(varName);
+  if (!isSubtypeOf(current, T.number) && current.kind !== "union") return [env, env];
+  const trueEnv = env.extend({});
+  const falseEnv = env.extend({});
+  const trueRange = op === ">=" ? createRange({ min: value }) : op === ">" ? createRange({ min: value + 1 }) : op === "<=" ? createRange({ max: value }) : createRange({ max: value - 1 });
+  const falseRange = op === ">=" ? createRange({ max: value - 1 }) : op === ">" ? createRange({ max: value }) : op === "<=" ? createRange({ min: value + 1 }) : createRange({ min: value });
+  trueEnv.bind(varName, trueRange);
+  falseEnv.bind(varName, falseRange);
+  return [trueEnv, falseEnv];
+}
 
 // src/evaluator.ts
 import {
   T as T2,
   simplifyUnion,
-  applyBinaryOp,
+  dispatchBinaryOp,
+  dispatchMethod,
+  dispatchProperty,
   Ops,
   createEnvironment,
   typeValueEquals as typeValueEquals2,
   typeValueToString,
-  isSubtypeOf
+  isSubtypeOf as isSubtypeOf2,
+  widenLiteral,
+  createTemplate
 } from "@nudojs/core";
 var RETURN_SIGNAL = Symbol("ReturnSignal");
 var BRANCH_SIGNAL = Symbol("BranchSignal");
@@ -235,6 +265,14 @@ function setModuleResolver(resolver) {
 var currentModuleResolver = null;
 var currentFileDir = "";
 var _nodeTypeCollector = null;
+var _sampleCount = 3;
+var _maxConcreteIter = 1e3;
+function setSampleCount(count) {
+  _sampleCount = count;
+}
+function setMaxConcreteIter(count) {
+  _maxConcreteIter = count;
+}
 function setNodeTypeCollector(collector) {
   _nodeTypeCollector = collector;
 }
@@ -374,7 +412,7 @@ function evaluateNode(node, env) {
           parts.map((p) => p.kind === "literal" ? String(p.value) : "").join("")
         );
       }
-      return T2.string;
+      return createTemplate(parts);
     }
     case "BinaryExpression": {
       const leftVal = evaluate(node.left, env);
@@ -387,7 +425,7 @@ function evaluateNode(node, env) {
       return distributeBinaryOverUnion(
         leftVal,
         rightVal,
-        (l, r) => applyBinaryOp(node.operator, l, r)
+        (l, r) => dispatchBinaryOp(node.operator, l, r)
       );
     }
     case "UnaryExpression": {
@@ -592,14 +630,14 @@ function evaluateNode(node, env) {
       return evaluateForIn(node, rightVal, env);
     }
     case "ForStatement": {
-      if (node.init) {
-        const initResult = evaluate(node.init, env);
-        if (isReturn(initResult) || isBranch(initResult) || isThrow(initResult)) return initResult;
-      }
-      return T2.undefined;
+      return evaluateForStatement(node, env);
+    }
+    case "WhileStatement": {
+      return evaluateWhileStatement(node, env);
+    }
+    case "DoWhileStatement": {
+      return evaluateDoWhileStatement(node, env);
     }
-    case "WhileStatement":
-      return T2.undefined;
     case "FunctionDeclaration": {
       if (!node.id) return T2.undefined;
       const paramNames = node.params.map(describeParam);
@@ -728,6 +766,16 @@ function evaluateNode(node, env) {
           if (propName === "length" && (obj.kind === "array" || obj.kind === "tuple")) {
             return obj.kind === "tuple" ? T2.literal(obj.elements.length) : T2.number;
           }
+          if (propName === "length" && obj.kind === "literal" && typeof obj.value === "string") {
+            return T2.literal(obj.value.length);
+          }
+          if (propName === "length" && obj.kind === "primitive" && obj.type === "string") {
+            return T2.number;
+          }
+          if (obj.kind === "refined") {
+            const result = dispatchProperty(obj, propName);
+            if (result !== void 0) return result;
+          }
           return T2.unknown;
         });
       }
@@ -921,8 +969,184 @@ function evaluateMethodCall(callee, args, env) {
   if (objVal.kind === "array" || objVal.kind === "tuple") {
     return evaluateArrayMethod(objVal, methodName, args, env);
   }
+  if (isStringLike(objVal)) {
+    const argVals = evaluateArgs(args, env);
+    if (isReturn(argVals) || isBranch(argVals) || isThrow(argVals)) return argVals;
+    if (objVal.kind === "refined") {
+      const refined = dispatchMethod(objVal, methodName, argVals);
+      if (refined !== void 0) return refined;
+    }
+    return evaluateStringMethod(objVal, methodName, argVals);
+  }
+  if (objVal.kind === "refined") {
+    const argVals = evaluateArgs(args, env);
+    if (isReturn(argVals) || isBranch(argVals) || isThrow(argVals)) return argVals;
+    const result = dispatchMethod(objVal, methodName, argVals);
+    if (result !== void 0) return result;
+  }
   return null;
 }
+function isStringLike(tv) {
+  if (tv.kind === "literal" && typeof tv.value === "string") return true;
+  if (tv.kind === "primitive" && tv.type === "string") return true;
+  if (tv.kind === "refined") return isStringLike(tv.base);
+  return false;
+}
+function evaluateStringMethod(receiver, method, args) {
+  if (receiver.kind === "literal" && typeof receiver.value === "string") {
+    return evaluateStringMethodLiteral(receiver.value, method, args);
+  }
+  return evaluateStringMethodAbstract(method, args);
+}
+function evaluateStringMethodLiteral(str, method, args) {
+  const litArg = (i) => {
+    const a = args[i];
+    if (a?.kind === "literal" && (typeof a.value === "string" || typeof a.value === "number")) return a.value;
+    return void 0;
+  };
+  switch (method) {
+    case "toUpperCase":
+      return T2.literal(str.toUpperCase());
+    case "toLowerCase":
+      return T2.literal(str.toLowerCase());
+    case "trim":
+      return T2.literal(str.trim());
+    case "trimStart":
+      return T2.literal(str.trimStart());
+    case "trimEnd":
+      return T2.literal(str.trimEnd());
+    case "charAt": {
+      const idx = litArg(0);
+      return typeof idx === "number" ? T2.literal(str.charAt(idx)) : T2.string;
+    }
+    case "charCodeAt": {
+      const idx = litArg(0);
+      return typeof idx === "number" ? T2.literal(str.charCodeAt(idx)) : T2.number;
+    }
+    case "at": {
+      const idx = litArg(0);
+      if (typeof idx === "number") {
+        const ch = str.at(idx);
+        return ch !== void 0 ? T2.literal(ch) : T2.undefined;
+      }
+      return T2.union(T2.string, T2.undefined);
+    }
+    case "startsWith": {
+      const search = litArg(0);
+      return typeof search === "string" ? T2.literal(str.startsWith(search)) : T2.boolean;
+    }
+    case "endsWith": {
+      const search = litArg(0);
+      return typeof search === "string" ? T2.literal(str.endsWith(search)) : T2.boolean;
+    }
+    case "includes": {
+      const search = litArg(0);
+      return typeof search === "string" ? T2.literal(str.includes(search)) : T2.boolean;
+    }
+    case "indexOf": {
+      const search = litArg(0);
+      return typeof search === "string" ? T2.literal(str.indexOf(search)) : T2.number;
+    }
+    case "lastIndexOf": {
+      const search = litArg(0);
+      return typeof search === "string" ? T2.literal(str.lastIndexOf(search)) : T2.number;
+    }
+    case "slice": {
+      const start = litArg(0);
+      const end = litArg(1);
+      if (typeof start === "number") {
+        return T2.literal(str.slice(start, typeof end === "number" ? end : void 0));
+      }
+      return T2.string;
+    }
+    case "substring": {
+      const start = litArg(0);
+      const end = litArg(1);
+      if (typeof start === "number") {
+        return T2.literal(str.substring(start, typeof end === "number" ? end : void 0));
+      }
+      return T2.string;
+    }
+    case "split": {
+      const sep = litArg(0);
+      if (typeof sep === "string") {
+        const parts = str.split(sep);
+        return T2.tuple(parts.map((p) => T2.literal(p)));
+      }
+      return T2.array(T2.string);
+    }
+    case "replace": {
+      const search = litArg(0);
+      const replacement = litArg(1);
+      if (typeof search === "string" && typeof replacement === "string") {
+        return T2.literal(str.replace(search, replacement));
+      }
+      return T2.string;
+    }
+    case "replaceAll": {
+      const search = litArg(0);
+      const replacement = litArg(1);
+      if (typeof search === "string" && typeof replacement === "string") {
+        return T2.literal(str.replaceAll(search, replacement));
+      }
+      return T2.string;
+    }
+    case "repeat": {
+      const count = litArg(0);
+      return typeof count === "number" ? T2.literal(str.repeat(count)) : T2.string;
+    }
+    case "padStart": {
+      const len = litArg(0);
+      const fill = litArg(1);
+      if (typeof len === "number") {
+        return T2.literal(str.padStart(len, typeof fill === "string" ? fill : void 0));
+      }
+      return T2.string;
+    }
+    case "padEnd": {
+      const len = litArg(0);
+      const fill = litArg(1);
+      if (typeof len === "number") {
+        return T2.literal(str.padEnd(len, typeof fill === "string" ? fill : void 0));
+      }
+      return T2.string;
+    }
+    default:
+      return null;
+  }
+}
+function evaluateStringMethodAbstract(method, _args) {
+  switch (method) {
+    case "toUpperCase":
+    case "toLowerCase":
+    case "trim":
+    case "trimStart":
+    case "trimEnd":
+    case "charAt":
+    case "slice":
+    case "substring":
+    case "replace":
+    case "replaceAll":
+    case "repeat":
+    case "padStart":
+    case "padEnd":
+      return T2.string;
+    case "charCodeAt":
+    case "indexOf":
+    case "lastIndexOf":
+      return T2.number;
+    case "at":
+      return T2.union(T2.string, T2.undefined);
+    case "startsWith":
+    case "endsWith":
+    case "includes":
+      return T2.boolean;
+    case "split":
+      return T2.array(T2.string);
+    default:
+      return null;
+  }
+}
 function evaluateObjectStaticMethod(method, obj) {
   if (obj.kind !== "object") {
     if (method === "keys") return T2.array(T2.string);
@@ -1153,6 +1377,130 @@ function bindForLoopVar(left, value, env) {
     env.bind(left.name, value);
   }
 }
+function getLoopVarNames(node) {
+  if (node.type === "VariableDeclaration") {
+    return node.declarations.map((d) => d.id?.type === "Identifier" ? d.id.name : null).filter((n) => n !== null);
+  }
+  return [];
+}
+function snapshotVars(names, env) {
+  const snap = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    snap.set(name, env.lookup(name));
+  }
+  return snap;
+}
+function varsStabilized(prev, curr) {
+  for (const [name, prevVal] of prev) {
+    const currVal = curr.get(name);
+    if (!currVal || !typeValueEquals2(prevVal, currVal)) return false;
+  }
+  return true;
+}
+function widenVars(names, env) {
+  for (const name of names) {
+    const val = env.lookup(name);
+    const widened = widenLiteral(val);
+    if (!typeValueEquals2(val, widened)) {
+      if (!env.update(name, widened)) env.bind(name, widened);
+    }
+  }
+}
+function evaluateForStatement(node, env) {
+  const loopEnv = env.extend({});
+  if (node.init) {
+    const initResult = evaluate(node.init, loopEnv);
+    if (isReturn(initResult) || isBranch(initResult) || isThrow(initResult)) return initResult;
+  }
+  const varNames = node.init ? getLoopVarNames(node.init) : [];
+  const returnValues = [];
+  let concreteCompleted = false;
+  for (let i = 0; i < _maxConcreteIter; i++) {
+    if (node.test) {
+      const testVal = evaluate(node.test, loopEnv);
+      if (isReturn(testVal) || isBranch(testVal) || isThrow(testVal)) return testVal;
+      if (testVal.kind === "literal" && testVal.value === false) {
+        concreteCompleted = true;
+        break;
+      }
+      if (testVal.kind !== "literal") break;
+    }
+    const bodyResult = evaluate(node.body, loopEnv);
+    if (isReturn(bodyResult)) {
+      returnValues.push(bodyResult.value);
+      concreteCompleted = true;
+      break;
+    }
+    if (isBranch(bodyResult)) {
+      returnValues.push(bodyResult.returnedValue);
+    }
+    if (node.update) {
+      const updateResult = evaluate(node.update, loopEnv);
+      if (isReturn(updateResult) || isBranch(updateResult) || isThrow(updateResult)) return updateResult;
+    }
+  }
+  if (!concreteCompleted) {
+    widenVars(varNames, loopEnv);
+    const prevSnap = snapshotVars(varNames, loopEnv);
+    for (let i = 0; i < 10; i++) {
+      evaluate(node.body, loopEnv);
+      if (node.update) evaluate(node.update, loopEnv);
+      widenVars(varNames, loopEnv);
+      const currSnap = snapshotVars(varNames, loopEnv);
+      if (varsStabilized(prevSnap, currSnap)) break;
+    }
+  }
+  for (const name of varNames) {
+    const val = loopEnv.lookup(name);
+    if (!env.update(name, val)) env.bind(name, val);
+  }
+  if (returnValues.length > 0) {
+    return makeBranch(simplifyUnion(returnValues), env);
+  }
+  return T2.undefined;
+}
+function evaluateWhileStatement(node, env) {
+  const returnValues = [];
+  for (let i = 0; i < _maxConcreteIter; i++) {
+    const tv = evaluate(node.test, env);
+    if (isReturn(tv) || isBranch(tv) || isThrow(tv)) return tv;
+    if (tv.kind === "literal" && tv.value === false) break;
+    if (tv.kind !== "literal") break;
+    const bodyResult = evaluate(node.body, env);
+    if (isReturn(bodyResult)) {
+      returnValues.push(bodyResult.value);
+      break;
+    }
+    if (isBranch(bodyResult)) {
+      returnValues.push(bodyResult.returnedValue);
+    }
+  }
+  if (returnValues.length > 0) {
+    return makeBranch(simplifyUnion(returnValues), env);
+  }
+  return T2.undefined;
+}
+function evaluateDoWhileStatement(node, env) {
+  const returnValues = [];
+  for (let i = 0; i < _maxConcreteIter; i++) {
+    const bodyResult = evaluate(node.body, env);
+    if (isReturn(bodyResult)) {
+      returnValues.push(bodyResult.value);
+      break;
+    }
+    if (isBranch(bodyResult)) {
+      returnValues.push(bodyResult.returnedValue);
+    }
+    const tv = evaluate(node.test, env);
+    if (isReturn(tv) || isBranch(tv) || isThrow(tv)) return tv;
+    if (tv.kind === "literal" && tv.value === false) break;
+    if (tv.kind !== "literal") break;
+  }
+  if (returnValues.length > 0) {
+    return makeBranch(simplifyUnion(returnValues), env);
+  }
+  return T2.undefined;
+}
 function evaluateImportDeclaration(node, env) {
   const source = node.source.value;
   if (!currentModuleResolver) return T2.undefined;
@@ -1222,7 +1570,7 @@ function evaluateInstanceof(left, _right, rightNode, _env) {
   if (!className) return T2.boolean;
   return distributeOverUnion(left, (lv) => {
     if (lv.kind === "instance") {
-      const matches = lv.className === className || isSubtypeOf(lv, T2.instanceOf(className));
+      const matches = lv.className === className || isSubtypeOf2(lv, T2.instanceOf(className));
       return T2.literal(matches);
     }
     return T2.boolean;
@@ -1456,6 +1804,8 @@ export {
   narrow,
   resetMemo,
   setModuleResolver,
+  setSampleCount,
+  setMaxConcreteIter,
   setNodeTypeCollector,
   evaluate,
   evaluateFunction,

package/dist/evaluator-api.d.ts

@@ -34,6 +34,8 @@ declare function setModuleResolver(resolver: ((source: string, fromDir: string)
     ast: Node;
     filePath: string;
 } | null) | null): void;
+declare function setSampleCount(count: number): void;
+declare function setMaxConcreteIter(count: number): void;
 declare function setNodeTypeCollector(collector: ((node: Node, tv: TypeValue) => void) | null): void;
 declare function evaluate(node: Node, env: Environment): EvalResult;
 type CallResult = {
@@ -54,4 +56,4 @@ declare function setCurrentFileDir(dir: string): void;
  */
 declare function narrow(test: Node, env: Environment): [trueEnv: Environment, falseEnv: Environment];
 
-export { evaluate, evaluateFunction, evaluateFunctionFull, evaluateProgram, getUnreachableRanges, narrow, resetMemo, resetUnreachableRanges, setCurrentFileDir, setModuleResolver, setNodeTypeCollector };
+export { evaluate, evaluateFunction, evaluateFunctionFull, evaluateProgram, getUnreachableRanges, narrow, resetMemo, resetUnreachableRanges, setCurrentFileDir, setMaxConcreteIter, setModuleResolver, setNodeTypeCollector, setSampleCount };

package/dist/evaluator-api.js

@@ -8,9 +8,11 @@ import {
   resetMemo,
   resetUnreachableRanges,
   setCurrentFileDir,
+  setMaxConcreteIter,
   setModuleResolver,
-  setNodeTypeCollector
-} from "./chunk-JW3RMCNY.js";
+  setNodeTypeCollector,
+  setSampleCount
+} from "./chunk-LGWVGEMB.js";
 export {
   evaluate,
   evaluateFunction,
@@ -21,6 +23,8 @@ export {
   resetMemo,
   resetUnreachableRanges,
   setCurrentFileDir,
+  setMaxConcreteIter,
   setModuleResolver,
-  setNodeTypeCollector
+  setNodeTypeCollector,
+  setSampleCount
 };

package/dist/index.js

@@ -8,7 +8,7 @@ import {
   resetMemo,
   setCurrentFileDir,
   setModuleResolver
-} from "./chunk-JW3RMCNY.js";
+} from "./chunk-LGWVGEMB.js";
 
 // ../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/error.js
 var require_error = __commonJS({
@@ -3336,7 +3336,9 @@ import {
   typeValueToString,
   simplifyUnion,
   createEnvironment,
-  isSubtypeOf
+  isSubtypeOf,
+  isTemplate,
+  getTemplateParts
 } from "@nudojs/core";
 import { parse, extractDirectives, parseTypeValueExpr } from "@nudojs/parser";
 var program2 = new Command();
@@ -3380,6 +3382,14 @@ function typeValueToTSType(tv) {
     }
     case "primitive":
       return tv.type;
+    case "refined": {
+      if (isTemplate(tv)) {
+        const parts = getTemplateParts(tv);
+        const inner = parts.map((p) => p.kind === "literal" && typeof p.value === "string" ? p.value : `\${${typeValueToTSType(p)}}`).join("");
+        return `\`${inner}\``;
+      }
+      return typeValueToTSType(tv.base);
+    }
     case "object": {
       const entries = Object.entries(tv.properties);
       if (entries.length === 0) return "{}";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nudojs/cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "main": "src/index.ts",
   "exports": {
@@ -10,9 +10,19 @@
   "bin": {
     "nudo": "src/index.ts"
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nudojs/nudo.git",
+    "directory": "packages/cli"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org"
+  },
   "dependencies": {
-    "@nudojs/core": "0.1.0",
-    "@nudojs/parser": "0.1.0"
+    "@nudojs/core": "0.2.0",
+    "@nudojs/parser": "0.2.0"
   },
   "scripts": {
     "build": "tsup src/index.ts src/evaluator-api.ts --format esm --dts"