@styx-api/core 0.6.1 → 0.8.0

package/src/frontend/boutiques/destruct-template.ts

@@ -20,29 +20,36 @@ export function destructTemplate<T>(template: string, lookup: Record<string, T>)
       continue;
     }
 
-    let didSplit = false;
-
+    // Pick the leftmost match; on a tie in position, the longest alias wins
+    // (maximal munch), so a value-key that is a prefix of another (e.g. `foo`
+    // vs `foobar`) does not shadow it by mere iteration order.
+    let best: { idx: number; alias: string; replacement: T } | null = null;
     for (const [alias, replacement] of Object.entries(lookup)) {
+      if (alias.length === 0) continue;
       const idx = x.indexOf(alias);
-      if (idx !== -1) {
-        const left = x.slice(0, idx);
-        const right = x.slice(idx + alias.length);
-
-        if (right.length > 0) {
-          stack.unshift(right);
-        }
-        stack.unshift(replacement);
-        if (left.length > 0) {
-          stack.unshift(left);
-        }
-
-        didSplit = true;
-        break;
+      if (idx === -1) continue;
+      if (
+        best === null ||
+        idx < best.idx ||
+        (idx === best.idx && alias.length > best.alias.length)
+      ) {
+        best = { idx, alias, replacement };
       }
     }
 
-    if (!didSplit) {
+    if (best === null) {
       destructed.push(x);
+      continue;
+    }
+
+    const left = x.slice(0, best.idx);
+    const right = x.slice(best.idx + best.alias.length);
+    if (right.length > 0) {
+      stack.unshift(right);
+    }
+    stack.unshift(best.replacement);
+    if (left.length > 0) {
+      stack.unshift(left);
     }
   }
 

package/src/frontend/boutiques/parser.ts

@@ -372,12 +372,21 @@ export class BoutiquesParser implements Frontend {
       case InputTypePrimitive.Integer: {
         const node: Int = { kind: "int", attrs: {} };
         if (isNumber(btInput.minimum)) {
-          node.attrs.minValue = Math.floor(btInput.minimum);
-          if (btInput["exclusive-minimum"] === true) node.attrs.minValue += 1;
+          // Smallest valid integer: for a fractional bound, `>= 5.7` allows 6
+          // (ceil) and `> 5.7` allows 6 (floor + 1); both differ from a plain
+          // floor.
+          node.attrs.minValue =
+            btInput["exclusive-minimum"] === true
+              ? Math.floor(btInput.minimum) + 1
+              : Math.ceil(btInput.minimum);
         }
         if (isNumber(btInput.maximum)) {
-          node.attrs.maxValue = Math.floor(btInput.maximum);
-          if (btInput["exclusive-maximum"] === true) node.attrs.maxValue -= 1;
+          // Largest valid integer: `<= 5.7` allows 5 (floor) and `< 5.7` allows
+          // 5 (ceil - 1).
+          node.attrs.maxValue =
+            btInput["exclusive-maximum"] === true
+              ? Math.ceil(btInput.maximum) - 1
+              : Math.floor(btInput.maximum);
         }
         if (meta) node.meta = meta;
         return node;
@@ -424,7 +433,10 @@ export class BoutiquesParser implements Frontend {
           return null;
         }
         const node = this.parseDescriptor(nested);
-        if (node && meta) node.meta = meta;
+        // Merge (not overwrite) so the subcommand's own meta - notably its
+        // `output-files`, attached by `parseDescriptor` - survives; the input's
+        // meta (name/doc) layers on top.
+        if (node && meta) node.meta = { ...node.meta, ...meta };
         return node;
       }
 
@@ -553,12 +565,19 @@ export class BoutiquesParser implements Frontend {
     }
 
     // Hoist metadata (doc, default) to outermost wrapper so backends find it
-    // on the binding node. Keep name on inner for solver's findDeepName.
+    // on the binding node. Keep `name` on inner for the solver's findDeepName,
+    // and keep `outputs` there too: outputs are a scope concept declared on the
+    // subcommand struct, not a property of the list/flag wrapper - hoisting them
+    // onto a repeat would move the output scope off the struct and make backends
+    // (which resolve outputs against the struct) silently drop them.
     if (node !== inner && inner.meta) {
-      const { name, ...rest } = inner.meta;
+      const { name, outputs, ...rest } = inner.meta;
       if (Object.keys(rest).length > 0) {
         node.meta = { ...node.meta, ...rest };
-        inner.meta = name ? { name } : undefined;
+        const kept: NodeMeta = {};
+        if (name) kept.name = name;
+        if (outputs) kept.outputs = outputs;
+        inner.meta = Object.keys(kept).length > 0 ? kept : undefined;
       }
     }
 

package/src/frontend/detect-format.ts

@@ -1,14 +1,39 @@
-export type FormatName = "boutiques" | "argdump" | "workbench" | "mrtrix";
+export type FormatName = "boutiques" | "argdump" | "workbench" | "mrtrix" | "argtype";
+
+/** The first non-whitespace character of a source ("" if it is all blank). */
+function firstNonBlankChar(source: string): string {
+  const match = source.match(/\S/);
+  return match ? match[0] : "";
+}
 
 /**
- * Auto-detect the format of a JSON descriptor source string.
- * Returns null if the format cannot be determined.
+ * Auto-detect the format of a descriptor source string.
+ *
+ * Every JSON frontend (boutiques, argdump, workbench, mrtrix) is a top-level
+ * object, so the first non-blank character being `{` is the signal for "some
+ * JSON format"; we then inspect its keys to pick which one. Anything else
+ * non-blank is treated as the argtype DSL, whose sources open with a terminal
+ * (`int`), a literal (`"hello"`), a combinator (`seq(...)`), a `name: expr`
+ * definition, or a `---` frontmatter fence - never with `{`.
+ *
+ * Deciding on the leading character (rather than trying `JSON.parse` first) is
+ * what lets standalone argtype snippets like `"hello"` or `42` be recognized:
+ * those are *also* valid JSON scalars, so a parse-first approach would swallow
+ * them and then reject them as "not an object".
+ *
+ * Returns null only when the source is blank, or opens with `{` but matches no
+ * known JSON format (ambiguous, or still being typed).
  */
 export function detectFormat(source: string): FormatName | null {
+  const first = firstNonBlankChar(source);
+  if (first === "") return null;
+  if (first !== "{") return "argtype";
+
   let parsed: unknown;
   try {
     parsed = JSON.parse(source);
   } catch {
+    // Opens like a JSON object but is not valid (yet) - e.g. mid-edit.
     return null;
   }
 

package/src/index.ts

@@ -1,4 +1,5 @@
 import { ArgdumpParser } from "./frontend/argdump/index.js";
+import { ArgtypeParser } from "./frontend/argtype/index.js";
 import { BoutiquesParser } from "./frontend/boutiques/index.js";
 import { MrtrixParser } from "./frontend/mrtrix/index.js";
 import { WorkbenchParser } from "./frontend/workbench/index.js";
@@ -22,7 +23,10 @@ export function compile(
       ? { filename: filenameOrOptions }
       : (filenameOrOptions ?? {});
 
-  const format = options.format ?? detectFormat(source);
+  // An explicit `.argtype` filename selects the DSL frontend even though the
+  // source is not JSON (detection by content is a fallback).
+  const byExtension = options.filename?.endsWith(".argtype") ? "argtype" : undefined;
+  const format = options.format ?? byExtension ?? detectFormat(source);
 
   if (!format) {
     return {
@@ -32,13 +36,23 @@ export function compile(
     };
   }
 
-  const parser =
-    format === "argdump"
-      ? new ArgdumpParser()
-      : format === "workbench"
-        ? new WorkbenchParser()
-        : format === "mrtrix"
-          ? new MrtrixParser()
-          : new BoutiquesParser();
+  const parser = ((): { parse: (s: string, f?: string) => ParseResult } => {
+    switch (format) {
+      case "argdump":
+        return new ArgdumpParser();
+      case "argtype":
+        return new ArgtypeParser();
+      case "workbench":
+        return new WorkbenchParser();
+      case "mrtrix":
+        return new MrtrixParser();
+      case "boutiques":
+        return new BoutiquesParser();
+      default: {
+        const _exhaustive: never = format;
+        return new BoutiquesParser();
+      }
+    }
+  })();
   return parser.parse(source, options.filename);
 }

package/src/ir/passes/canonicalize.ts

@@ -38,6 +38,19 @@ export const canonicalize: Pass = {
       }
     }
 
+    // Identity for dedup: structure plus the meta that makes two structurally
+    // identical union arms semantically distinct - the variant tag (@type
+    // discriminant), name, and attached outputs. Deduping on structure alone
+    // would silently drop a distinct arm (e.g. two sub-commands with the same
+    // inner shape but different @type), making its variant unreachable.
+    function identityKey(node: Expr): string {
+      const m = node.meta;
+      const metaKey = m
+        ? [m.name ?? "", m.variantTag ?? "", m.outputs ? JSON.stringify(m.outputs) : ""].join("|")
+        : "";
+      return `${structuralHash(node)}#${metaKey}`;
+    }
+
     function sortKey(node: Expr): string {
       const name = node.meta?.name ?? "";
       return `${node.kind}:${name}:${structuralHash(node)}`;
@@ -51,13 +64,13 @@ export const canonicalize: Pass = {
           // Sort alternatives
           const sorted = [...children].sort((a, b) => sortKey(a).localeCompare(sortKey(b)));
 
-          // Deduplicate by structural hash
+          // Deduplicate identical arms (structure + discriminating meta).
           const seen = new Set<string>();
           const alts: Expr[] = [];
           for (const child of sorted) {
-            const hash = structuralHash(child);
-            if (!seen.has(hash)) {
-              seen.add(hash);
+            const key = identityKey(child);
+            if (!seen.has(key)) {
+              seen.add(key);
               alts.push(child);
             } else {
               changed = true;
@@ -67,7 +80,7 @@ export const canonicalize: Pass = {
           // Check if order changed
           if (
             alts.length !== children.length ||
-            alts.some((alt, i) => structuralHash(alt) !== structuralHash(children[i]!))
+            alts.some((alt, i) => identityKey(alt) !== identityKey(children[i]!))
           ) {
             changed = true;
           }

package/src/ir/passes/simplify.ts

@@ -127,15 +127,30 @@ export const simplify: Pass = {
               node.attrs.join === ""
             ) {
               changed = true;
-              prev.attrs.str += child.attrs.str;
+              // Replace with a fresh node - `prev` is the original literal object
+              // (the `literal` case returns `node` unchanged), so mutating it in
+              // place would corrupt the caller's IR and double-append on rerun.
+              nodes[nodes.length - 1] = {
+                ...prev,
+                attrs: { ...prev.attrs, str: prev.attrs.str + child.attrs.str },
+              };
             } else {
               nodes.push(child);
             }
           }
 
-          // seq(T) -> T, carrying the seq's meta down onto the child.
+          // seq(T) -> T, carrying the seq's meta down onto the child. Skip the
+          // collapse when the sequence declares outputs and the sole child is a
+          // literal: outputs need a scope binding, which the solver only forces
+          // on sequences (not on literals, which are never bound). Collapsing a
+          // parameterless output-bearing command (e.g. `seq(lit("run"))` with an
+          // output-file) onto its literal would orphan the output. A field child
+          // (str/path) does get bound, so those still collapse.
           if (nodes.length === 1) {
             const child = nodes[0]!;
+            if (node.meta?.outputs?.length && child.kind === "literal") {
+              return { ...node, attrs: { ...node.attrs, nodes } };
+            }
             changed = true;
             const mergedMeta = mergeMeta(node.meta, child.meta);
             return mergedMeta ? { ...child, meta: mergedMeta } : child;

package/src/solver/solver.ts

@@ -45,11 +45,11 @@ function isBooleanLiteralPair(variants: Array<{ type: BoundType }>): boolean {
     return false;
   }
   const [a, b] = variants.map((v) => (v.type.kind === "literal" ? v.type.value : null));
+  // `literalFromNode` canonicalizes clean-int literals, so "0"/"1" arrive as the
+  // numbers 0/1 (never strings); only "false"/"true" survive as strings.
   return (
     (a === 0 && b === 1) ||
     (a === 1 && b === 0) ||
-    (a === "0" && b === "1") ||
-    (a === "1" && b === "0") ||
     (a === "false" && b === "true") ||
     (a === "true" && b === "false")
   );