@shrkcrft/cli 0.1.0-alpha.2

package/dist/command-registry.d.ts

@@ -0,0 +1,158 @@
+export interface ParsedArgs {
+    positional: string[];
+    flags: Map<string, string | boolean>;
+    /** Captures every occurrence (including repeats) for flags like --var. */
+    multiFlags: Map<string, string[]>;
+    /** Resolved global cwd (absolute), if --cwd was passed at the top level. */
+    globalCwd?: string;
+}
+export interface ICommandHandler {
+    name: string;
+    description: string;
+    usage: string;
+    run(args: ParsedArgs): Promise<number> | number;
+}
+/**
+ * Trie node backing the registry. A node can carry a handler (the verb
+ * at this path is callable) and/or children (further verbs nested below).
+ * Aliases live at the node — `pack.aliases.set('author2', 'author')` makes
+ * `shrk pack author2 status` resolve via `pack/author/status`.
+ */
+interface ICommandTrieNode {
+    handler?: ICommandHandler;
+    readonly children: Map<string, ICommandTrieNode>;
+    readonly aliases: Map<string, string>;
+}
+/** Result of a greedy descent through the trie. */
+export interface ICommandResolution {
+    /** Handler at the deepest matched path (may be undefined if it's a pure group). */
+    handler?: ICommandHandler;
+    /** The canonical segments that matched (aliases already resolved). */
+    matchedPath: string[];
+    /** Tokens left over after the descent stopped (passed to the handler). */
+    rest: string[];
+    /** The trie node where the descent stopped — useful for help/suggestions. */
+    node: ICommandTrieNode;
+}
+/**
+ * Trie-backed command registry. Supports N-level dispatch
+ * (`shrk pack author status`) while keeping the historical 1- and 2-level
+ * API working as degenerate cases.
+ *
+ * Aliases:
+ *   - `aliasCommand(a, c)` — top-level alias (`shrk a` → `shrk c`).
+ *   - `aliasGroup(a, c)` — top-level group alias (`shrk a list` → `shrk c list`).
+ *   - `aliasAt(path, alias, canonical)` — alias at arbitrary depth.
+ */
+export declare class CommandRegistry {
+    private readonly root;
+    /** Mirrors of the trie root for the legacy listGroupAliases/listCommandAliases API. */
+    private readonly groupAliases;
+    private readonly commandAliases;
+    /** Register a top-level command (`shrk <name>`). */
+    register(command: ICommandHandler): void;
+    /** Register a 2-level command (`shrk <group> <name>`). */
+    registerSubcommand(group: string, command: ICommandHandler): void;
+    /**
+     * Register a command at an arbitrary depth (`shrk a b c <name>`).
+     * Path is the full sequence of segments; the LAST segment is the verb
+     * (the command name).
+     */
+    registerAt(path: readonly string[], command: ICommandHandler): void;
+    /** Legacy: top-level group alias. */
+    aliasGroup(alias: string, canonical: string): void;
+    /** Legacy: top-level command alias. */
+    aliasCommand(alias: string, canonical: string): void;
+    /** Alias at arbitrary depth. Path is the parent of the alias. */
+    aliasAt(parentPath: readonly string[], alias: string, canonical: string): void;
+    /** Top-level command lookup. */
+    get(name: string): ICommandHandler | undefined;
+    /** 2-level command lookup. */
+    getSub(group: string, name: string): ICommandHandler | undefined;
+    /** Handler at an arbitrary path (exact match, no descent). */
+    getAt(path: readonly string[]): ICommandHandler | undefined;
+    resolveGroup(group: string): string;
+    listGroups(): readonly string[];
+    listGroup(group: string): readonly ICommandHandler[];
+    /** Immediate subgroup names of a group (nodes with their own children). */
+    listSubgroups(path: readonly string[]): readonly string[];
+    listGroupAliases(): ReadonlyMap<string, string>;
+    listCommandAliases(): ReadonlyMap<string, string>;
+    /** Top-level commands (handlers at depth 1). */
+    list(): readonly ICommandHandler[];
+    /** Every handler in the trie with its full path. */
+    listAll(): ReadonlyArray<{
+        readonly path: readonly string[];
+        readonly handler: ICommandHandler;
+    }>;
+    /**
+     * Greedy dispatch resolution. Descends as deep as possible through
+     * the trie. Stops when:
+     *   1. The next token is a flag (`--foo` / `-f`).
+     *   2. The current node has no matching child for the next token.
+     *
+     * Returns the deepest node's handler, the canonical path that matched,
+     * and the remaining tokens (passed to the handler).
+     */
+    resolve(tokens: readonly string[]): ICommandResolution;
+    private descend;
+    private collectAll;
+}
+export interface ParseArgsOptions {
+    /** Global cwd resolved during pre-parse, propagated to the command. */
+    globalCwd?: string;
+}
+export declare function parseArgs(argv: readonly string[], options?: ParseArgsOptions): ParsedArgs;
+/**
+ * Extracts `--cwd <value>` / `--cwd=<value>` from anywhere in argv. Used as a
+ * pre-pass before command dispatch so a user can write `shrk --cwd ./repo doctor`.
+ */
+export declare function extractGlobalCwd(argv: readonly string[]): {
+    cwd?: string;
+    rest: string[];
+};
+/**
+ * Returns the absolute cwd for the current command:
+ * 1. Command-level --cwd flag (if passed after the command)
+ * 2. Global --cwd (extracted at the top level)
+ * 3. process.cwd()
+ */
+export declare function resolveCwd(args: ParsedArgs): string;
+export declare function flagString(args: ParsedArgs, name: string): string | undefined;
+export declare function flagBool(args: ParsedArgs, name: string): boolean;
+export declare function flagNumber(args: ParsedArgs, name: string): number | undefined;
+/**
+ * Canonical multi-value flag parser.
+ *
+ * Accepts every form the CLI has historically used:
+ *
+ *   --tag a --tag b           → ['a','b']
+ *   --tag a,b                 → ['a','b']
+ *   --tag "a, b, c"           → ['a','b','c']
+ *   --tag=a --tag=b           → ['a','b']
+ *   (mixed)                   → flattened, trimmed, empties dropped.
+ *
+ * Replaces the older `flagStringList` (comma-only) and the one-off
+ * `multiValues()` helpers that accreted across commands.
+ */
+export interface IFlagListOptions {
+    /** Remove duplicates while preserving first occurrence. Default false. */
+    dedupe?: boolean;
+    /** Allowlist — values outside this set are filtered out silently. */
+    allow?: readonly string[];
+    /**
+     * Controls comma splitting:
+     *
+     *   - `'always'` (default) — every occurrence is comma-split.
+     *   - `'never'` — keep each occurrence verbatim (use when a single value
+     *     may legitimately contain commas, e.g. structured refs).
+     *   - `'auto'` — comma-split when the flag was passed once; keep
+     *     occurrences verbatim when passed multiple times. Useful for
+     *     `--reference "kind:value"` shapes.
+     */
+    split?: 'always' | 'never' | 'auto';
+}
+export declare function flagList(args: ParsedArgs, name: string, options?: IFlagListOptions): string[];
+export declare function flagVars(args: ParsedArgs): Record<string, string>;
+export {};
+//# sourceMappingURL=command-registry.d.ts.map

package/dist/command-registry.d.ts.map

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

package/dist/command-registry.js

@@ -0,0 +1,348 @@
+import * as nodePath from 'node:path';
+function makeTrieNode() {
+    return { children: new Map(), aliases: new Map() };
+}
+/**
+ * Trie-backed command registry. Supports N-level dispatch
+ * (`shrk pack author status`) while keeping the historical 1- and 2-level
+ * API working as degenerate cases.
+ *
+ * Aliases:
+ *   - `aliasCommand(a, c)` — top-level alias (`shrk a` → `shrk c`).
+ *   - `aliasGroup(a, c)` — top-level group alias (`shrk a list` → `shrk c list`).
+ *   - `aliasAt(path, alias, canonical)` — alias at arbitrary depth.
+ */
+export class CommandRegistry {
+    root = makeTrieNode();
+    /** Mirrors of the trie root for the legacy listGroupAliases/listCommandAliases API. */
+    groupAliases = new Map();
+    commandAliases = new Map();
+    /** Register a top-level command (`shrk <name>`). */
+    register(command) {
+        this.registerAt([command.name], command);
+    }
+    /** Register a 2-level command (`shrk <group> <name>`). */
+    registerSubcommand(group, command) {
+        this.registerAt([group, command.name], command);
+    }
+    /**
+     * Register a command at an arbitrary depth (`shrk a b c <name>`).
+     * Path is the full sequence of segments; the LAST segment is the verb
+     * (the command name).
+     */
+    registerAt(path, command) {
+        if (path.length === 0) {
+            throw new Error('registerAt: path must have at least one segment');
+        }
+        let node = this.root;
+        for (const seg of path) {
+            let child = node.children.get(seg);
+            if (!child) {
+                child = makeTrieNode();
+                node.children.set(seg, child);
+            }
+            node = child;
+        }
+        node.handler = command;
+    }
+    /** Legacy: top-level group alias. */
+    aliasGroup(alias, canonical) {
+        this.groupAliases.set(alias, canonical);
+        this.root.aliases.set(alias, canonical);
+    }
+    /** Legacy: top-level command alias. */
+    aliasCommand(alias, canonical) {
+        this.commandAliases.set(alias, canonical);
+        this.root.aliases.set(alias, canonical);
+    }
+    /** Alias at arbitrary depth. Path is the parent of the alias. */
+    aliasAt(parentPath, alias, canonical) {
+        let node = this.root;
+        for (const seg of parentPath) {
+            let child = node.children.get(seg);
+            if (!child) {
+                child = makeTrieNode();
+                node.children.set(seg, child);
+            }
+            node = child;
+        }
+        node.aliases.set(alias, canonical);
+    }
+    /** Top-level command lookup. */
+    get(name) {
+        const canonical = this.root.aliases.get(name) ?? name;
+        return this.root.children.get(canonical)?.handler;
+    }
+    /** 2-level command lookup. */
+    getSub(group, name) {
+        const node = this.descend([group]);
+        if (!node)
+            return undefined;
+        const canonical = node.aliases.get(name) ?? name;
+        return node.children.get(canonical)?.handler;
+    }
+    /** Handler at an arbitrary path (exact match, no descent). */
+    getAt(path) {
+        const node = this.descend(path);
+        return node?.handler;
+    }
+    resolveGroup(group) {
+        return this.root.aliases.get(group) ?? group;
+    }
+    listGroups() {
+        // Canonical groups at depth 1 (children with their own children) plus
+        // every top-level alias. Mirrors the historical behaviour.
+        const out = [];
+        for (const [name, node] of this.root.children) {
+            if (node.children.size > 0)
+                out.push(name);
+        }
+        for (const alias of this.root.aliases.keys())
+            out.push(alias);
+        return out;
+    }
+    listGroup(group) {
+        const canonical = this.root.aliases.get(group) ?? group;
+        const node = this.root.children.get(canonical);
+        if (!node)
+            return [];
+        // Immediate verbs only (matches the legacy 2-level semantics). Use
+        // `listSubgroups(group)` to discover nested groups.
+        return [...node.children.values()]
+            .map((c) => c.handler)
+            .filter((h) => h !== undefined);
+    }
+    /** Immediate subgroup names of a group (nodes with their own children). */
+    listSubgroups(path) {
+        const node = this.descend(path);
+        if (!node)
+            return [];
+        const out = [];
+        for (const [name, child] of node.children) {
+            if (child.children.size > 0)
+                out.push(name);
+        }
+        return out;
+    }
+    listGroupAliases() {
+        return this.groupAliases;
+    }
+    listCommandAliases() {
+        return this.commandAliases;
+    }
+    /** Top-level commands (handlers at depth 1). */
+    list() {
+        const out = [];
+        for (const child of this.root.children.values()) {
+            if (child.handler)
+                out.push(child.handler);
+        }
+        return out;
+    }
+    /** Every handler in the trie with its full path. */
+    listAll() {
+        const out = [];
+        this.collectAll(this.root, [], out);
+        return out;
+    }
+    /**
+     * Greedy dispatch resolution. Descends as deep as possible through
+     * the trie. Stops when:
+     *   1. The next token is a flag (`--foo` / `-f`).
+     *   2. The current node has no matching child for the next token.
+     *
+     * Returns the deepest node's handler, the canonical path that matched,
+     * and the remaining tokens (passed to the handler).
+     */
+    resolve(tokens) {
+        let node = this.root;
+        const matched = [];
+        let i = 0;
+        while (i < tokens.length) {
+            const t = tokens[i];
+            if (t.startsWith('-'))
+                break;
+            const canonical = node.aliases.get(t) ?? t;
+            const child = node.children.get(canonical);
+            if (!child)
+                break;
+            node = child;
+            matched.push(canonical);
+            i += 1;
+        }
+        return {
+            handler: node.handler,
+            matchedPath: matched,
+            rest: tokens.slice(i),
+            node,
+        };
+    }
+    descend(path) {
+        let node = this.root;
+        for (const seg of path) {
+            if (!node)
+                return undefined;
+            const canonical = node.aliases.get(seg) ?? seg;
+            node = node.children.get(canonical);
+        }
+        return node;
+    }
+    collectAll(node, prefix, out) {
+        for (const [name, child] of node.children) {
+            const path = [...prefix, name];
+            if (child.handler)
+                out.push({ path, handler: child.handler });
+            this.collectAll(child, path, out);
+        }
+    }
+}
+function addMultiFlag(map, key, value) {
+    const arr = map.get(key) ?? [];
+    arr.push(value);
+    map.set(key, arr);
+}
+export function parseArgs(argv, options = {}) {
+    const positional = [];
+    const flags = new Map();
+    const multiFlags = new Map();
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === '--') {
+            positional.push(...argv.slice(i + 1));
+            break;
+        }
+        if (arg.startsWith('--')) {
+            const eq = arg.indexOf('=');
+            let key;
+            let value;
+            if (eq !== -1) {
+                key = arg.slice(2, eq);
+                value = arg.slice(eq + 1);
+            }
+            else {
+                key = arg.slice(2);
+                const next = argv[i + 1];
+                if (next !== undefined && !next.startsWith('-')) {
+                    value = next;
+                    i += 1;
+                }
+                else {
+                    value = true;
+                }
+            }
+            flags.set(key, value);
+            if (typeof value === 'string')
+                addMultiFlag(multiFlags, key, value);
+        }
+        else if (arg.startsWith('-')) {
+            const key = arg.slice(1);
+            flags.set(key, true);
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    const out = { positional, flags, multiFlags };
+    if (options.globalCwd)
+        out.globalCwd = options.globalCwd;
+    return out;
+}
+/**
+ * Extracts `--cwd <value>` / `--cwd=<value>` from anywhere in argv. Used as a
+ * pre-pass before command dispatch so a user can write `shrk --cwd ./repo doctor`.
+ */
+export function extractGlobalCwd(argv) {
+    const rest = [];
+    let cwd;
+    for (let i = 0; i < argv.length; i += 1) {
+        const t = argv[i];
+        if (t === '--cwd') {
+            const next = argv[i + 1];
+            if (next !== undefined && !next.startsWith('-')) {
+                cwd = next;
+                i += 1;
+                continue;
+            }
+            // No value — leave it; command-level parser may complain.
+            rest.push(t);
+            continue;
+        }
+        if (t.startsWith('--cwd=')) {
+            cwd = t.slice('--cwd='.length);
+            continue;
+        }
+        rest.push(t);
+    }
+    if (cwd && !nodePath.isAbsolute(cwd))
+        cwd = nodePath.resolve(process.cwd(), cwd);
+    return cwd === undefined ? { rest } : { cwd, rest };
+}
+/**
+ * Returns the absolute cwd for the current command:
+ * 1. Command-level --cwd flag (if passed after the command)
+ * 2. Global --cwd (extracted at the top level)
+ * 3. process.cwd()
+ */
+export function resolveCwd(args) {
+    const flag = args.flags.get('cwd');
+    if (typeof flag === 'string')
+        return nodePath.resolve(flag);
+    if (args.globalCwd)
+        return args.globalCwd;
+    return process.cwd();
+}
+export function flagString(args, name) {
+    const v = args.flags.get(name);
+    return typeof v === 'string' ? v : undefined;
+}
+export function flagBool(args, name) {
+    const v = args.flags.get(name);
+    return v === true || v === 'true';
+}
+export function flagNumber(args, name) {
+    const v = args.flags.get(name);
+    if (typeof v !== 'string')
+        return undefined;
+    const n = Number(v);
+    return Number.isFinite(n) ? n : undefined;
+}
+export function flagList(args, name, options = {}) {
+    const split = options.split ?? 'always';
+    const raw = args.multiFlags.get(name) ?? [];
+    let entries;
+    if (split === 'never' || (split === 'auto' && raw.length > 1)) {
+        entries = raw.map((v) => v.trim()).filter(Boolean);
+    }
+    else {
+        entries = raw.flatMap((v) => v
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean));
+    }
+    if (options.allow && options.allow.length) {
+        const allow = new Set(options.allow);
+        entries = entries.filter((v) => allow.has(v));
+    }
+    if (options.dedupe) {
+        const seen = new Set();
+        const out = [];
+        for (const v of entries) {
+            if (!seen.has(v)) {
+                seen.add(v);
+                out.push(v);
+            }
+        }
+        return out;
+    }
+    return entries;
+}
+export function flagVars(args) {
+    const out = {};
+    const list = args.multiFlags.get('var') ?? [];
+    for (const item of list) {
+        const eq = item.indexOf('=');
+        if (eq !== -1)
+            out[item.slice(0, eq)] = item.slice(eq + 1);
+    }
+    return out;
+}

package/dist/commands/apply.command.d.ts

@@ -0,0 +1,3 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const applyCommand: ICommandHandler;
+//# sourceMappingURL=apply.command.d.ts.map

package/dist/commands/apply.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply.command.d.ts","sourceRoot":"","sources":["../../src/commands/apply.command.ts"],"names":[],"mappings":"AAqDA,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAyLhC,eAAO,MAAM,YAAY,EAAE,eAyrB1B,CAAC"}