@officexapp/vidfarm-devcli 0.21.54 → 0.21.56

package/dist/src/devcli/doctor.js

@@ -7,7 +7,7 @@
 // else prints as ⚠/✗ but does not fail the command, so agents can run doctor
 // unconditionally at session start.
 import { spawnSync } from "node:child_process";
-import { existsSync, readdirSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import net from "node:net";
 import { homedir } from "node:os";
@@ -143,6 +143,28 @@ export async function runDoctorCommand(argv) {
     const killOrphans = Boolean(parsed.values["kill-orphans"]);
     const checks = [];
     const add = (name, level, detail) => checks.push({ name, level, detail });
+    // 0. Are the two halves current, and are they the SAME version? The skill and
+    // the devcli ship on one semver, and a gap between them is the usual cause of
+    // "that command doesn't exist" — so it belongs in the health check, not only
+    // in the update runbook. Never fails the doctor: offline is not a defect, and
+    // a pending update is information, not breakage.
+    try {
+        const { installedDevcliVersion, installedSkillPath, readSkillVersion, compareSemver, readUpdateState, hoursSinceLastCheck } = await import("./update-check.js");
+        const devcli = installedDevcliVersion();
+        const skillPath = installedSkillPath();
+        const skill = skillPath ? readSkillVersion(readFileSync(skillPath, "utf8")) : null;
+        const since = hoursSinceLastCheck(readUpdateState());
+        const staleNote = since === null ? " · never checked for updates" : since >= 24 ? ` · last update check ${Math.round(since / 24)}d ago` : "";
+        if (devcli && skill && compareSemver(devcli, skill) !== 0) {
+            add("versions", "warn", `devcli ${devcli} vs skill ${skill} — MISMATCHED. They ship together; run: vidfarm update-check`);
+        }
+        else {
+            add("versions", since !== null && since < 24 ? "ok" : "warn", `devcli ${devcli ?? "?"} · skill ${skill ?? "not installed"}${staleNote}${staleNote ? " — vidfarm update-check" : ""}`);
+        }
+    }
+    catch {
+        // A version probe must never take the doctor down with it.
+    }
     // 1. Node version.
     const nodeMajor = Number(process.versions.node.split(".")[0]);
     add("node", nodeMajor >= 22 ? "ok" : "fail", `v${process.versions.node}${nodeMajor >= 22 ? "" : " — vidfarm-devcli needs Node >= 22"}`);

package/dist/src/devcli/harness.js

@@ -59,10 +59,10 @@ const DISCOVERY_NAMES = ["HARNESS.md", "harness.md", "QA_REGIME.md", "qa_regime.
 // They ship inside the skill pack (.agents/skills/vidfarm/harnesses/) rather
 // than as TS string constants, so a director can read, diff, and copy them as
 // normal files — the file IS the documentation.
-function builtinDir() {
+function packDir(...segments) {
     let dir = path.dirname(fileURLToPath(import.meta.url));
     for (let i = 0; i < 6; i += 1) {
-        const candidate = path.join(dir, ".agents", "skills", "vidfarm", "harnesses");
+        const candidate = path.join(dir, ...segments);
         if (existsSync(candidate))
             return candidate;
         const parent = path.dirname(dir);
@@ -72,32 +72,77 @@ function builtinDir() {
     }
     return null;
 }
-export function listBuiltinHarnesses() {
-    const dir = builtinDir();
+function builtinDir() {
+    return packDir(".agents", "skills", "vidfarm", "harnesses");
+}
+// The EXPERIMENTAL harnesses — full format contracts under live testing, served
+// at https://vidfarm.cc/experimental/<slug>.md. They ship inside the npm package
+// too (`experimental/**/*.md` in package.json `files`), so an agent that already
+// has the CLI reaches them by NAME, offline, with no fetch: `vidfarm harness show
+// meme-recaption`, `vidfarm qa ./work --harness wall-text-pov-ugc`. The web index
+// stays the source of truth for what exists; this is the same shelf, local.
+function experimentalDir() {
+    return packDir("experimental");
+}
+function readEntry(full, name, origin) {
+    const parsed = parseHarness(readFileSync(full, "utf8"), full);
+    return {
+        name,
+        path: full,
+        video_type: parsed.video_type,
+        summary: parsed.summary,
+        origin,
+        ...(origin === "experimental" ? { url: `https://vidfarm.cc/experimental/${name}.md` } : {})
+    };
+}
+export function listExperimentalHarnesses() {
+    const dir = experimentalDir();
     if (!dir)
         return [];
     return readdirSync(dir)
-        .filter((file) => file.endsWith(BUILTIN_SUFFIX))
+        .filter((file) => file.endsWith(".md"))
         .sort()
-        .map((file) => {
-        const full = path.join(dir, file);
-        const parsed = parseHarness(readFileSync(full, "utf8"), full);
-        return { name: file.slice(0, -BUILTIN_SUFFIX.length), path: full, video_type: parsed.video_type, summary: parsed.summary };
-    });
+        .map((file) => readEntry(path.join(dir, file), file.slice(0, -".md".length), "experimental"));
 }
-/** Resolve `hooks` (built-in) or `./my/HARNESS.md` (a path) to a file. */
+/** Both shelves, built-ins first. `vidfarm harness list` prints exactly this. */
+export function listBuiltinHarnesses() {
+    const dir = builtinDir();
+    const builtins = !dir
+        ? []
+        : readdirSync(dir)
+            .filter((file) => file.endsWith(BUILTIN_SUFFIX))
+            .sort()
+            .map((file) => readEntry(path.join(dir, file), file.slice(0, -BUILTIN_SUFFIX.length), "builtin"));
+    return [...builtins, ...listExperimentalHarnesses()];
+}
+/**
+ * Resolve `hooks` (built-in), `meme-recaption` (experimental), or
+ * `./my/HARNESS.md` (a path) to a file. Underscore spellings resolve too, so the
+ * URL slug and the CLI name never disagree — the same near-miss the web route
+ * forgives with its aliases.
+ */
 export function resolveHarnessPath(ref) {
     const direct = path.resolve(ref);
     if (existsSync(direct) && !direct.endsWith(path.sep))
         return direct;
-    const dir = builtinDir();
-    if (dir) {
-        const candidate = path.join(dir, `${ref}${BUILTIN_SUFFIX}`);
+    const slug = ref.trim().toLowerCase().replace(/\.md$/, "").replace(/_/g, "-");
+    const builtins = builtinDir();
+    if (builtins) {
+        for (const name of [ref, slug]) {
+            const candidate = path.join(builtins, `${name}${BUILTIN_SUFFIX}`);
+            if (existsSync(candidate))
+                return candidate;
+        }
+    }
+    const experimental = experimentalDir();
+    if (experimental) {
+        const candidate = path.join(experimental, `${slug}.md`);
         if (existsSync(candidate))
             return candidate;
     }
     const names = listBuiltinHarnesses().map((entry) => entry.name);
-    throw new Error(`No harness "${ref}". Pass a file path, or one of the built-ins: ${names.join(", ") || "(none bundled)"}. ` +
+    throw new Error(`No harness "${ref}". Pass a file path, or one of the bundled names: ${names.join(", ") || "(none bundled)"}. ` +
+        `The live index is https://vidfarm.cc/experimental. ` +
         `Scaffold your own with \`vidfarm harness init <name> --out ./work/HARNESS.md\`, ` +
         `or derive one from a decomposed template with \`vidfarm harness derive <forkId>\`.`);
 }