@ldlework/workmark 1.1.0 → 1.2.0

package/dist/cli.js

@@ -1,42 +1,7 @@
 #!/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
 // ---------------------------------------------------------------------------
@@ -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/helpers.d.ts

@@ -5,5 +5,7 @@ export interface ExecOptions {
     cwd: string;
     timeout?: number;
 }
+export declare function execRaw(command: string, opts: ExecOptions): string;
 export declare function exec(command: string, opts: ExecOptions): CallToolResult;
+export declare function execAsyncRaw(command: string, opts: ExecOptions): Promise<string>;
 export declare function execAsync(command: string, opts: ExecOptions): Promise<CallToolResult>;

package/dist/lib/helpers.js

@@ -25,32 +25,38 @@ export function fail(error) {
     }
     return { content: [{ type: "text", text: msg }], isError: true };
 }
-export function exec(command, opts) {
+export function execRaw(command, opts) {
     const { cwd, timeout = 120_000 } = opts;
+    return execSync(command, {
+        cwd,
+        timeout,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"],
+        maxBuffer: 1024 * 1024 * 10,
+    });
+}
+export function exec(command, opts) {
     try {
-        return ok(execSync(command, {
-            cwd,
-            timeout,
-            encoding: "utf-8",
-            stdio: ["ignore", "pipe", "pipe"],
-            maxBuffer: 1024 * 1024 * 10,
-        }));
+        return ok(execRaw(command, opts));
     }
     catch (e) {
         return fail(e);
     }
 }
 const execPromise = promisify(cpExec);
-export async function execAsync(command, opts) {
+export async function execAsyncRaw(command, opts) {
     const { cwd, timeout = 120_000 } = opts;
+    const { stdout } = await execPromise(command, {
+        cwd,
+        timeout,
+        encoding: "utf-8",
+        maxBuffer: 1024 * 1024 * 10,
+    });
+    return stdout;
+}
+export async function execAsync(command, opts) {
     try {
-        const { stdout } = await execPromise(command, {
-            cwd,
-            timeout,
-            encoding: "utf-8",
-            maxBuffer: 1024 * 1024 * 10,
-        });
-        return ok(stdout);
+        return ok(await execAsyncRaw(command, opts));
     }
     catch (e) {
         return fail(e);

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ldlework/workmark",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "type": "module",
   "main": "dist/lib/load.js",
   "bin": {

package/src/cli.ts

@@ -2,49 +2,9 @@
 
 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
 // ---------------------------------------------------------------------------
@@ -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/helpers.ts

@@ -37,18 +37,20 @@ export interface ExecOptions {
   timeout?: number; // ms, default 120_000
 }
 
-export function exec(command: string, opts: ExecOptions): CallToolResult {
+export function execRaw(command: string, opts: ExecOptions): string {
   const { cwd, timeout = 120_000 } = opts;
+  return execSync(command, {
+    cwd,
+    timeout,
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"],
+    maxBuffer: 1024 * 1024 * 10,
+  });
+}
+
+export function exec(command: string, opts: ExecOptions): CallToolResult {
   try {
-    return ok(
-      execSync(command, {
-        cwd,
-        timeout,
-        encoding: "utf-8",
-        stdio: ["ignore", "pipe", "pipe"],
-        maxBuffer: 1024 * 1024 * 10,
-      }),
-    );
+    return ok(execRaw(command, opts));
   } catch (e) {
     return fail(e);
   }
@@ -56,19 +58,26 @@ export function exec(command: string, opts: ExecOptions): CallToolResult {
 
 const execPromise = promisify(cpExec);
 
+export async function execAsyncRaw(
+  command: string,
+  opts: ExecOptions,
+): Promise<string> {
+  const { cwd, timeout = 120_000 } = opts;
+  const { stdout } = await execPromise(command, {
+    cwd,
+    timeout,
+    encoding: "utf-8",
+    maxBuffer: 1024 * 1024 * 10,
+  });
+  return stdout;
+}
+
 export async function execAsync(
   command: string,
   opts: ExecOptions,
 ): Promise<CallToolResult> {
-  const { cwd, timeout = 120_000 } = opts;
   try {
-    const { stdout } = await execPromise(command, {
-      cwd,
-      timeout,
-      encoding: "utf-8",
-      maxBuffer: 1024 * 1024 * 10,
-    });
-    return ok(stdout);
+    return ok(await execAsyncRaw(command, opts));
   } catch (e) {
     return fail(e);
   }

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);
+}