@ldlework/workmark 1.1.1 → 1.3.0

package/dist/cli.js

@@ -1,47 +1,12 @@
 #!/usr/bin/env node
 import { loadCommands } from "./lib/load.js";
 import { loadWorkspace } from "./lib/workspace.js";
-// ---------------------------------------------------------------------------
-// Arg parsing
-// ---------------------------------------------------------------------------
-function parseValue(raw) {
-    if (raw === "true")
-        return true;
-    if (raw === "false")
-        return false;
-    const n = Number(raw);
-    if (!Number.isNaN(n) && raw !== "")
-        return n;
-    return raw;
-}
-function parseArgs(argv, positionalNames) {
-    const args = {};
-    let posIdx = 0;
-    for (let i = 0; i < argv.length; i++) {
-        const token = argv[i];
-        if (token.startsWith("--")) {
-            const key = token.slice(2);
-            const next = argv[i + 1];
-            if (next === undefined || next.startsWith("--")) {
-                args[key] = true;
-            }
-            else {
-                args[key] = parseValue(next);
-                i++;
-            }
-        }
-        else if (posIdx < positionalNames.length) {
-            args[positionalNames[posIdx]] = parseValue(token);
-            posIdx++;
-        }
-    }
-    return args;
-}
+import { parseArgs } from "./lib/parse.js";
 // ---------------------------------------------------------------------------
 // Help
 // ---------------------------------------------------------------------------
 function printHelp(commands) {
-    console.log("Usage: ws <command> [args...]\n");
+    console.log("Usage: wm <command> [args...]\n");
     // Group by group name
     const groups = new Map();
     for (const cmd of commands) {
@@ -78,7 +43,7 @@ function printHelp(commands) {
 }
 function printCommandHelp(cmd) {
     const pos = cmd.positional.map((p) => `<${p}>`).join(" ");
-    console.log(`Usage: ws ${cmd.name} ${pos}\n`);
+    console.log(`Usage: wm ${cmd.name} ${pos}\n`);
     console.log(cmd.description);
     const schema = cmd.inputSchema;
     const props = schema.properties;
@@ -123,7 +88,7 @@ async function main() {
     const cmd = cmdMap.get(command);
     if (!cmd) {
         console.error(`Unknown command: ${command}`);
-        console.error(`Run 'ws --help' for available commands.`);
+        console.error(`Run 'wm --help' for available commands.`);
         process.exit(1);
     }
     // Per-command help
@@ -131,7 +96,7 @@ async function main() {
         printCommandHelp(cmd);
         return;
     }
-    const args = parseArgs(rest, cmd.positional);
+    const args = parseArgs(rest, cmd.positional, cmd.inputSchema);
     const result = await cmd.handler(args);
     for (const content of result.content) {
         if (content.type === "text") {

package/dist/lib/jiti-options.d.ts

@@ -1,6 +1,6 @@
 import type { JitiOptions } from "jiti";
 /**
- * Build jiti options that let ws.ts / command files import from
+ * Build jiti options that let wm.ts / command files import from
  * `@ldlework/workmark/*` and from workmark's own dependencies (zod, etc.)
  * regardless of how the package is installed or linked.
  */

package/dist/lib/jiti-options.js

@@ -4,7 +4,7 @@ import { fileURLToPath } from "node:url";
 const PKG_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
 const SRC_LIB = join(PKG_ROOT, "src", "lib");
 /**
- * Build jiti options that let ws.ts / command files import from
+ * Build jiti options that let wm.ts / command files import from
  * `@ldlework/workmark/*` and from workmark's own dependencies (zod, etc.)
  * regardless of how the package is installed or linked.
  */

package/dist/lib/load.js

@@ -72,7 +72,7 @@ function resolve(def, workspace, group, sourceFile) {
     return { name: def.name, label: def.label, group, description: def.description, inputSchema, positional, handler, sourceFile };
 }
 export async function loadCommands(workspace) {
-    const commandsDir = join(workspace.root, ".ws", "commands");
+    const commandsDir = join(workspace.root, ".wm", "commands");
     if (!existsSync(commandsDir))
         return [];
     const jiti = createJiti(commandsDir, jitiOptions());

package/dist/lib/parse.d.ts

@@ -0,0 +1,13 @@
+/**
+ * CLI argument parsing, in three phases:
+ *
+ *   1. tokenize  — turn argv into a structured token stream (flags vs. positionals)
+ *   2. dispatch  — bind tokens to parameter names using positional order and
+ *                  schema-declared array flags (repeats accumulate)
+ *   3. coerce    — convert raw strings to JSON Schema-declared types
+ *
+ * Each phase is independently testable and has one job. Coercion is driven by
+ * the command's JSON Schema rather than heuristics, so `z.string()` fields
+ * always stay strings and `z.array(...)` fields always come out as arrays.
+ */
+export declare function parseArgs(argv: string[], positional: string[], schema: Record<string, unknown>): Record<string, unknown>;

package/dist/lib/parse.js

@@ -0,0 +1,113 @@
+/**
+ * CLI argument parsing, in three phases:
+ *
+ *   1. tokenize  — turn argv into a structured token stream (flags vs. positionals)
+ *   2. dispatch  — bind tokens to parameter names using positional order and
+ *                  schema-declared array flags (repeats accumulate)
+ *   3. coerce    — convert raw strings to JSON Schema-declared types
+ *
+ * Each phase is independently testable and has one job. Coercion is driven by
+ * the command's JSON Schema rather than heuristics, so `z.string()` fields
+ * always stay strings and `z.array(...)` fields always come out as arrays.
+ */
+// --- 1. tokenize ---------------------------------------------------------
+function tokenize(argv) {
+    const tokens = [];
+    for (let i = 0; i < argv.length; i++) {
+        const tok = argv[i];
+        if (!tok.startsWith("--")) {
+            tokens.push({ kind: "positional", value: tok });
+            continue;
+        }
+        const eq = tok.indexOf("=");
+        if (eq >= 0) {
+            tokens.push({ kind: "flag", key: tok.slice(2, eq), value: tok.slice(eq + 1) });
+            continue;
+        }
+        const key = tok.slice(2);
+        const next = argv[i + 1];
+        if (next === undefined || next.startsWith("--")) {
+            tokens.push({ kind: "flag", key });
+        }
+        else {
+            tokens.push({ kind: "flag", key, value: next });
+            i++;
+        }
+    }
+    return tokens;
+}
+// --- 2. dispatch ---------------------------------------------------------
+function isArrayField(schema, name) {
+    return schema.properties?.[name]?.type === "array";
+}
+function appendToArray(out, key, value) {
+    const prev = out[key];
+    out[key] = Array.isArray(prev) ? [...prev, value] : [value];
+}
+function assignFlag(out, schema, key, value) {
+    if (value === undefined) {
+        out[key] = true;
+        return;
+    }
+    if (isArrayField(schema, key)) {
+        appendToArray(out, key, value);
+        return;
+    }
+    out[key] = value;
+}
+function dispatch(tokens, positional, schema) {
+    const out = {};
+    let posIdx = 0;
+    for (const tok of tokens) {
+        if (tok.kind === "flag") {
+            assignFlag(out, schema, tok.key, tok.value);
+        }
+        else if (posIdx < positional.length) {
+            out[positional[posIdx]] = tok.value;
+            posIdx++;
+        }
+    }
+    return out;
+}
+// --- 3. coerce -----------------------------------------------------------
+function coerceScalar(raw, type) {
+    switch (type) {
+        case "number":
+        case "integer": {
+            const n = Number(raw);
+            return Number.isNaN(n) ? raw : n;
+        }
+        case "boolean":
+            if (raw === "true")
+                return true;
+            if (raw === "false")
+                return false;
+            return raw;
+        default:
+            return raw;
+    }
+}
+function coerceField(value, prop) {
+    if (prop === undefined)
+        return value;
+    if (typeof value === "boolean")
+        return value;
+    if (prop.type === "array") {
+        const items = Array.isArray(value) ? value : [value];
+        return items.map((item) => coerceScalar(String(item), prop.items?.type));
+    }
+    return coerceScalar(String(value), prop.type);
+}
+function coerce(raw, schema) {
+    const out = {};
+    const props = schema.properties ?? {};
+    for (const [key, value] of Object.entries(raw)) {
+        out[key] = coerceField(value, props[key]);
+    }
+    return out;
+}
+// --- orchestrator --------------------------------------------------------
+export function parseArgs(argv, positional, schema) {
+    const s = schema;
+    return coerce(dispatch(tokenize(argv), positional, s), s);
+}

package/dist/lib/types.d.ts

@@ -7,7 +7,7 @@ export type SchemaFields = Record<string, z.ZodType | Record<string, unknown>>;
 export interface ProjectDef {
     /** Unique identifier. */
     name: string;
-    /** Project directory relative to the ws.ts location. Defaults to ".". */
+    /** Project directory relative to the wm.ts location. Defaults to ".". */
     dir?: string;
     /** Arbitrary string tags for grouping/filtering. */
     tags?: string[];

package/dist/lib/workspace.js

@@ -44,8 +44,8 @@ function loadIgnore(root) {
     }
     return ig;
 }
-/** Recursively find all ws.ts files, respecting .gitignore rules. */
-function findWsFiles(root) {
+/** Recursively find all wm.ts files, respecting .gitignore rules. */
+function findWmFiles(root) {
     const ig = loadIgnore(root);
     const results = [];
     function walk(dir) {
@@ -55,7 +55,7 @@ function findWsFiles(root) {
                 if (!ig.ignores(rel + "/"))
                     walk(join(dir, entry.name));
             }
-            else if (entry.name === "ws.ts") {
+            else if (entry.name === "wm.ts") {
                 results.push(join(dir, entry.name));
             }
         }
@@ -63,35 +63,35 @@ function findWsFiles(root) {
     walk(root);
     return results;
 }
-/** Find the workspace root by walking up from cwd looking for .ws/. */
+/** Find the workspace root by walking up from cwd looking for .wm/. */
 function findRoot(from) {
     let dir = from;
     while (true) {
-        if (existsSync(join(dir, ".ws"))) {
+        if (existsSync(join(dir, ".wm"))) {
             return dir;
         }
         const parent = dirname(dir);
         if (parent === dir)
-            throw new Error("Could not find workspace root (.ws/ directory)");
+            throw new Error("Could not find workspace root (.wm/ directory)");
         dir = parent;
     }
 }
 export async function loadWorkspace(from) {
     const root = from ?? process.env.WORKSPACE_ROOT ?? findRoot(process.cwd());
     const jiti = createJiti(root, jitiOptions());
-    // Recursively find all ws.ts files
-    const wsFiles = findWsFiles(root);
+    // Recursively find all wm.ts files
+    const wmFiles = findWmFiles(root);
     // Import each and build Project instances
     const projects = [];
-    for (const wsFile of wsFiles) {
-        const dir = dirname(wsFile);
+    for (const wmFile of wmFiles) {
+        const dir = dirname(wmFile);
         let exported;
         try {
-            exported = await jiti.import(wsFile);
+            exported = await jiti.import(wmFile);
         }
         catch (err) {
-            // Log import failures — helps debug bad ws.ts files
-            console.error(`[workspace] Skipping ${wsFile}: ${err.message}`);
+            // Log import failures — helps debug bad wm.ts files
+            console.error(`[workspace] Skipping ${wmFile}: ${err.message}`);
             continue;
         }
         // jiti may return { default: ... } when interopDefault doesn't fully unwrap

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@ldlework/workmark",
-  "version": "1.1.1",
+  "version": "1.3.0",
   "type": "module",
   "main": "dist/lib/load.js",
   "bin": {
-    "ws": "dist/cli.js"
+    "wm": "dist/cli.js"
   },
   "engines": {
     "node": ">=18"

package/src/cli.ts

@@ -2,55 +2,15 @@
 
 import { loadCommands } from "./lib/load.js";
 import { loadWorkspace } from "./lib/workspace.js";
+import { parseArgs } from "./lib/parse.js";
 import type { ResolvedCommand } from "./lib/types.js";
 
-
-// ---------------------------------------------------------------------------
-// Arg parsing
-// ---------------------------------------------------------------------------
-
-function parseValue(raw: string): unknown {
-  if (raw === "true") return true;
-  if (raw === "false") return false;
-  const n = Number(raw);
-  if (!Number.isNaN(n) && raw !== "") return n;
-  return raw;
-}
-
-function parseArgs(
-  argv: string[],
-  positionalNames: string[],
-): Record<string, unknown> {
-  const args: Record<string, unknown> = {};
-  let posIdx = 0;
-
-  for (let i = 0; i < argv.length; i++) {
-    const token = argv[i];
-
-    if (token.startsWith("--")) {
-      const key = token.slice(2);
-      const next = argv[i + 1];
-      if (next === undefined || next.startsWith("--")) {
-        args[key] = true;
-      } else {
-        args[key] = parseValue(next);
-        i++;
-      }
-    } else if (posIdx < positionalNames.length) {
-      args[positionalNames[posIdx]] = parseValue(token);
-      posIdx++;
-    }
-  }
-
-  return args;
-}
-
 // ---------------------------------------------------------------------------
 // Help
 // ---------------------------------------------------------------------------
 
 function printHelp(commands: ResolvedCommand[]): void {
-  console.log("Usage: ws <command> [args...]\n");
+  console.log("Usage: wm <command> [args...]\n");
 
   // Group by group name
   const groups = new Map<string, ResolvedCommand[]>();
@@ -91,7 +51,7 @@ function printHelp(commands: ResolvedCommand[]): void {
 
 function printCommandHelp(cmd: ResolvedCommand): void {
   const pos = cmd.positional.map((p) => `<${p}>`).join(" ");
-  console.log(`Usage: ws ${cmd.name} ${pos}\n`);
+  console.log(`Usage: wm ${cmd.name} ${pos}\n`);
   console.log(cmd.description);
 
   const schema = cmd.inputSchema as {
@@ -143,7 +103,7 @@ async function main(): Promise<void> {
   const cmd = cmdMap.get(command);
   if (!cmd) {
     console.error(`Unknown command: ${command}`);
-    console.error(`Run 'ws --help' for available commands.`);
+    console.error(`Run 'wm --help' for available commands.`);
     process.exit(1);
   }
 
@@ -153,7 +113,7 @@ async function main(): Promise<void> {
     return;
   }
 
-  const args = parseArgs(rest, cmd.positional);
+  const args = parseArgs(rest, cmd.positional, cmd.inputSchema);
   const result = await cmd.handler(args);
 
   for (const content of result.content) {

package/src/lib/jiti-options.ts

@@ -7,7 +7,7 @@ const PKG_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
 const SRC_LIB = join(PKG_ROOT, "src", "lib");
 
 /**
- * Build jiti options that let ws.ts / command files import from
+ * Build jiti options that let wm.ts / command files import from
  * `@ldlework/workmark/*` and from workmark's own dependencies (zod, etc.)
  * regardless of how the package is installed or linked.
  */

package/src/lib/load.ts

@@ -87,7 +87,7 @@ function resolve(def: CommandDef, workspace: IWorkspace, group: string, sourceFi
 }
 
 export async function loadCommands(workspace: IWorkspace): Promise<ResolvedCommand[]> {
-  const commandsDir = join(workspace.root, ".ws", "commands");
+  const commandsDir = join(workspace.root, ".wm", "commands");
   if (!existsSync(commandsDir)) return [];
 
   const jiti = createJiti(commandsDir, jitiOptions());

package/src/lib/parse.ts

@@ -0,0 +1,155 @@
+/**
+ * CLI argument parsing, in three phases:
+ *
+ *   1. tokenize  — turn argv into a structured token stream (flags vs. positionals)
+ *   2. dispatch  — bind tokens to parameter names using positional order and
+ *                  schema-declared array flags (repeats accumulate)
+ *   3. coerce    — convert raw strings to JSON Schema-declared types
+ *
+ * Each phase is independently testable and has one job. Coercion is driven by
+ * the command's JSON Schema rather than heuristics, so `z.string()` fields
+ * always stay strings and `z.array(...)` fields always come out as arrays.
+ */
+
+type Token =
+  | { kind: "flag"; key: string; value?: string }
+  | { kind: "positional"; value: string };
+
+type SchemaProp = {
+  type?: string;
+  items?: { type?: string; enum?: unknown[] };
+  enum?: unknown[];
+};
+
+type SchemaObject = {
+  properties?: Record<string, SchemaProp>;
+};
+
+// --- 1. tokenize ---------------------------------------------------------
+
+function tokenize(argv: string[]): Token[] {
+  const tokens: Token[] = [];
+  for (let i = 0; i < argv.length; i++) {
+    const tok = argv[i];
+    if (!tok.startsWith("--")) {
+      tokens.push({ kind: "positional", value: tok });
+      continue;
+    }
+
+    const eq = tok.indexOf("=");
+    if (eq >= 0) {
+      tokens.push({ kind: "flag", key: tok.slice(2, eq), value: tok.slice(eq + 1) });
+      continue;
+    }
+
+    const key = tok.slice(2);
+    const next = argv[i + 1];
+    if (next === undefined || next.startsWith("--")) {
+      tokens.push({ kind: "flag", key });
+    } else {
+      tokens.push({ kind: "flag", key, value: next });
+      i++;
+    }
+  }
+  return tokens;
+}
+
+// --- 2. dispatch ---------------------------------------------------------
+
+function isArrayField(schema: SchemaObject, name: string): boolean {
+  return schema.properties?.[name]?.type === "array";
+}
+
+function appendToArray(out: Record<string, unknown>, key: string, value: string): void {
+  const prev = out[key];
+  out[key] = Array.isArray(prev) ? [...prev, value] : [value];
+}
+
+function assignFlag(
+  out: Record<string, unknown>,
+  schema: SchemaObject,
+  key: string,
+  value: string | undefined,
+): void {
+  if (value === undefined) {
+    out[key] = true;
+    return;
+  }
+  if (isArrayField(schema, key)) {
+    appendToArray(out, key, value);
+    return;
+  }
+  out[key] = value;
+}
+
+function dispatch(
+  tokens: Token[],
+  positional: string[],
+  schema: SchemaObject,
+): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  let posIdx = 0;
+
+  for (const tok of tokens) {
+    if (tok.kind === "flag") {
+      assignFlag(out, schema, tok.key, tok.value);
+    } else if (posIdx < positional.length) {
+      out[positional[posIdx]] = tok.value;
+      posIdx++;
+    }
+  }
+  return out;
+}
+
+// --- 3. coerce -----------------------------------------------------------
+
+function coerceScalar(raw: string, type?: string): unknown {
+  switch (type) {
+    case "number":
+    case "integer": {
+      const n = Number(raw);
+      return Number.isNaN(n) ? raw : n;
+    }
+    case "boolean":
+      if (raw === "true") return true;
+      if (raw === "false") return false;
+      return raw;
+    default:
+      return raw;
+  }
+}
+
+function coerceField(value: unknown, prop: SchemaProp | undefined): unknown {
+  if (prop === undefined) return value;
+  if (typeof value === "boolean") return value;
+
+  if (prop.type === "array") {
+    const items = Array.isArray(value) ? value : [value];
+    return items.map((item) => coerceScalar(String(item), prop.items?.type));
+  }
+
+  return coerceScalar(String(value), prop.type);
+}
+
+function coerce(
+  raw: Record<string, unknown>,
+  schema: SchemaObject,
+): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  const props = schema.properties ?? {};
+  for (const [key, value] of Object.entries(raw)) {
+    out[key] = coerceField(value, props[key]);
+  }
+  return out;
+}
+
+// --- orchestrator --------------------------------------------------------
+
+export function parseArgs(
+  argv: string[],
+  positional: string[],
+  schema: Record<string, unknown>,
+): Record<string, unknown> {
+  const s = schema as SchemaObject;
+  return coerce(dispatch(tokenize(argv), positional, s), s);
+}

package/src/lib/types.ts

@@ -7,12 +7,12 @@ export type InputSchema = z.ZodType | Record<string, unknown>;
 /** A record of named Zod schemas or raw JSON Schema property objects. */
 export type SchemaFields = Record<string, z.ZodType | Record<string, unknown>>;
 
-// ---- Project definitions (used in ws.ts files) ----
+// ---- Project definitions (used in wm.ts files) ----
 
 export interface ProjectDef {
   /** Unique identifier. */
   name: string;
-  /** Project directory relative to the ws.ts location. Defaults to ".". */
+  /** Project directory relative to the wm.ts location. Defaults to ".". */
   dir?: string;
   /** Arbitrary string tags for grouping/filtering. */
   tags?: string[];

package/src/lib/workspace.ts

@@ -52,8 +52,8 @@ function loadIgnore(root: string): Ignore {
   return ig;
 }
 
-/** Recursively find all ws.ts files, respecting .gitignore rules. */
-function findWsFiles(root: string): string[] {
+/** Recursively find all wm.ts files, respecting .gitignore rules. */
+function findWmFiles(root: string): string[] {
   const ig = loadIgnore(root);
   const results: string[] = [];
 
@@ -62,7 +62,7 @@ function findWsFiles(root: string): string[] {
       const rel = relative(root, join(dir, entry.name));
       if (entry.isDirectory()) {
         if (!ig.ignores(rel + "/")) walk(join(dir, entry.name));
-      } else if (entry.name === "ws.ts") {
+      } else if (entry.name === "wm.ts") {
         results.push(join(dir, entry.name));
       }
     }
@@ -72,15 +72,15 @@ function findWsFiles(root: string): string[] {
   return results;
 }
 
-/** Find the workspace root by walking up from cwd looking for .ws/. */
+/** Find the workspace root by walking up from cwd looking for .wm/. */
 function findRoot(from: string): string {
   let dir = from;
   while (true) {
-    if (existsSync(join(dir, ".ws"))) {
+    if (existsSync(join(dir, ".wm"))) {
       return dir;
     }
     const parent = dirname(dir);
-    if (parent === dir) throw new Error("Could not find workspace root (.ws/ directory)");
+    if (parent === dir) throw new Error("Could not find workspace root (.wm/ directory)");
     dir = parent;
   }
 }
@@ -89,20 +89,20 @@ export async function loadWorkspace(from?: string): Promise<Workspace> {
   const root = from ?? process.env.WORKSPACE_ROOT ?? findRoot(process.cwd());
   const jiti = createJiti(root, jitiOptions());
 
-  // Recursively find all ws.ts files
-  const wsFiles = findWsFiles(root);
+  // Recursively find all wm.ts files
+  const wmFiles = findWmFiles(root);
 
   // Import each and build Project instances
   const projects: Project[] = [];
 
-  for (const wsFile of wsFiles) {
-    const dir = dirname(wsFile);
+  for (const wmFile of wmFiles) {
+    const dir = dirname(wmFile);
     let exported: unknown;
     try {
-      exported = await jiti.import(wsFile);
+      exported = await jiti.import(wmFile);
     } catch (err) {
-      // Log import failures — helps debug bad ws.ts files
-      console.error(`[workspace] Skipping ${wsFile}: ${(err as Error).message}`);
+      // Log import failures — helps debug bad wm.ts files
+      console.error(`[workspace] Skipping ${wmFile}: ${(err as Error).message}`);
       continue;
     }