@vodmal/vdx-cli 0.4.0 → 0.5.0

package/README.md

@@ -19,9 +19,34 @@ npx -y -p @vodmal/vdx-cli vdx audit /path/to/project
 ## Use
 
 ```bash
+# Lifecycle verbs (pass-through to `mise run <verb>`; requires mise + mise.toml)
+vdx up | down | build | test | check | fix
+
+# Maturity audit against the owner baseline rubric
 vdx audit <project-path> [--json] [--rubric <path>] [--stack <id>]
-vdx init  <project-path> [--baseline github.com/org/repo@vX.Y] [--dry-run] [--force]
-vdx-mcp   --project <path>   # MCP stdio server (used by the plugin)
+
+# Generate mise.toml + AGENTS.md for a project
+vdx init  <project-path> [--baseline github.com/org/repo@vX.Y] [--stack <id>] [--dry-run] [--force]
+
+# Publish a library (Node MVP; PHP/Python coming in Y.3)
+vdx publish <patch|minor|major> [--dry-run] [--force]
+
+# MCP stdio server consumed by the Claude Code plugin
+vdx-mcp   --project <path>
+```
+
+**Three quick examples**
+
+```bash
+# 1. Score the project I'm standing in
+vdx audit .
+
+# 2. Wire native scripts into the 6 lifecycle verbs, then run one
+vdx init . --stack node
+vdx test            # → mise run test (which calls `vitest run` or whatever was detected)
+
+# 3. Ship a new minor release of a Node lib
+vdx publish minor   # bump → npm publish (OTP prompt) → git commit + tag (no push)
 ```
 
 By default the bundled `rubric/vdx-rubric.yaml` is used (a mirror of canonical
@@ -48,6 +73,9 @@ npm run typecheck
 - `src/evaluator.ts`  — recursive evaluator + sugar notation
 - `src/scoring.ts`    — delta-style levels, flags for orthogonal axes
 - `src/audit.ts`      — orchestrator: overrides + applies_to filter + subpackage-ctx
+- `src/init.ts`       — `vdx init` planner (`selectVerbTask` + mise.toml/AGENTS.md renderers)
+- `src/run.ts`        — `resolveLifecycleVerb` + error renderer (pure logic for `vdx <verb>`)
+- `src/publish.ts`    — `planPublish` (pre-flight) + `executePublish` (bump → npm → git)
 - `src/report.ts`     — markdown / JSON output
 - `src/index.ts`      — CLI entry
 - `src/mcp-server.ts` — MCP stdio server (9 tools)
@@ -60,4 +88,8 @@ npm run typecheck
 - Baseline loading from a git ref is documented but evaluator still reads file
   paths only — `baseline:` in `mise.toml` is recorded but does not auto-fetch.
 - Watermark drift (phase 2 of `drift-algorithm.md`).
-- O25/O26/O27/O33/O34 — see [docs/decisions.md](../docs/decisions.md).
+- `vdx publish` only ships for Node (MVP). PHP/Python in Y.3; Cargo/Ruby/Go/Java
+  in Y.4.
+- Open items: O25 (mock-infra delta for Node), O26 (TOML round-trip), O27 (real
+  shared-infra precheck), O32 (multi-subpackage monorepo). See
+  [docs/decisions.md](../docs/decisions.md).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vodmal/vdx-cli",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "vdx — unified lifecycle interface (up/down/build/test/check/fix) + versioned maturity audit with drift detection. Pairs with the vdx Claude Code plugin.",
   "keywords": [
     "vdx",

package/src/index.ts

@@ -1,8 +1,15 @@
 #!/usr/bin/env node
 import * as path from 'node:path';
+import { execFileSync } from 'node:child_process';
 import { loadRubric } from './rubric.ts';
 import { loadManifest, loadOverrides } from './manifest.ts';
 import { autoDetectStack, type Ctx } from './facts.ts';
+import {
+  LIFECYCLE_VERBS,
+  type LifecycleVerb,
+  resolveLifecycleVerb,
+  renderResolveError,
+} from './run.ts';
 import { audit } from './audit.ts';
 import { reportMarkdown, reportJson } from './report.ts';
 import { planInit, writeInit, renderPlanSummary } from './init.ts';
@@ -20,6 +27,7 @@ const DEFAULT_RUBRIC = resolveDefaultRubric();
 function usage(): never {
   process.stderr.write(
     `Usage:
+  vdx <up|down|build|test|check|fix>     run lifecycle verb (via mise run <verb>)
   vdx audit   <project_path> [--rubric <path>] [--stack <stack>] [--json]
   vdx init    <project_path> [--stack <id>] [--baseline <ref>] [--dry-run] [--force]
   vdx publish <patch|minor|major> [--dry-run] [--force]
@@ -176,8 +184,32 @@ function cmdPublish(opts: ParsedArgs): void {
   }
 }
 
+function cmdRun(verb: LifecycleVerb): void {
+  const projectRoot = process.cwd();
+  const res = resolveLifecycleVerb(projectRoot, verb);
+  if (!res.ok) {
+    process.stderr.write(renderResolveError(res, projectRoot, verb));
+    process.exit(2);
+  }
+
+  try {
+    execFileSync('mise', ['run', verb], { cwd: projectRoot, stdio: 'inherit' });
+  } catch (e: any) {
+    if (e?.code === 'ENOENT') {
+      process.stderr.write(
+        `vdx: \`mise\` binary not found on PATH\n` +
+          `hint: install mise — https://mise.jdx.dev/getting-started.html\n`,
+      );
+      process.exit(127);
+    }
+    process.exit(typeof e?.status === 'number' ? e.status : 1);
+  }
+}
+
 const parsed = parseArgs(process.argv);
 if (parsed.cmd === 'audit') cmdAudit(parsed);
 else if (parsed.cmd === 'init') cmdInit(parsed);
 else if (parsed.cmd === 'publish') cmdPublish(parsed);
+else if ((LIFECYCLE_VERBS as readonly string[]).includes(parsed.cmd))
+  cmdRun(parsed.cmd as LifecycleVerb);
 else usage();

package/src/run.ts

@@ -0,0 +1,56 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as TOML from 'smol-toml';
+
+export const LIFECYCLE_VERBS = ['up', 'down', 'build', 'test', 'check', 'fix'] as const;
+export type LifecycleVerb = (typeof LIFECYCLE_VERBS)[number];
+
+export type VerbResolveResult =
+  | { ok: true; miseTomlPath: string }
+  | {
+      ok: false;
+      reason: 'no-mise-toml' | 'parse-error' | 'no-task';
+      detail?: string;
+    };
+
+export function resolveLifecycleVerb(
+  projectRoot: string,
+  verb: string,
+): VerbResolveResult {
+  const miseTomlPath = path.join(projectRoot, 'mise.toml');
+  if (!fs.existsSync(miseTomlPath)) {
+    return { ok: false, reason: 'no-mise-toml' };
+  }
+  let parsed: unknown;
+  try {
+    parsed = TOML.parse(fs.readFileSync(miseTomlPath, 'utf8'));
+  } catch (e: any) {
+    return { ok: false, reason: 'parse-error', detail: e?.message ?? String(e) };
+  }
+  const tasks = (parsed as { tasks?: Record<string, unknown> })?.tasks;
+  if (!tasks || typeof tasks !== 'object' || !(verb in tasks)) {
+    return { ok: false, reason: 'no-task' };
+  }
+  return { ok: true, miseTomlPath };
+}
+
+export function renderResolveError(
+  res: Exclude<VerbResolveResult, { ok: true }>,
+  projectRoot: string,
+  verb: string,
+): string {
+  switch (res.reason) {
+    case 'no-mise-toml':
+      return (
+        `vdx: no mise.toml in ${projectRoot}\n` +
+        `hint: run \`vdx init .\` to generate one, or define it manually.\n`
+      );
+    case 'parse-error':
+      return `vdx: failed to parse mise.toml: ${res.detail ?? 'unknown error'}\n`;
+    case 'no-task':
+      return (
+        `vdx: no \`[tasks.${verb}]\` in mise.toml\n` +
+        `hint: run \`vdx init . --force\` to re-detect, or add the task manually.\n`
+      );
+  }
+}