@odla-ai/cli 0.18.0 → 0.19.0

package/dist/bin.js

@@ -2,7 +2,7 @@
 import {
   exitCodeFor,
   runCli
-} from "./chunk-TOSMNGGQ.js";
+} from "./chunk-QMA5OGKQ.js";
 
 // src/bin.ts
 runCli().catch((err) => {

package/dist/{chunk-TOSMNGGQ.js → chunk-QMA5OGKQ.js}

@@ -5942,6 +5942,7 @@ Usage:
   odla-ai runbook ask "<question>" [--app <id>] [--all] [--json]
   odla-ai runbook search "<question>" [--app <id>] [--all] [--limit <n>] [--json]
   odla-ai runbook impact [--base origin/main] [--app <id>] [--all] [--limit <n>] [--json]
+  odla-ai runbook lint [--app <id>] [--all] [--json]
   odla-ai runbook list [--app <id>] [--all] [--q <text>] [--json]
   odla-ai runbook comment <slug> --body "..." [--app <id>]
   odla-ai runbook get <slug> [--app <id>]
@@ -5988,7 +5989,10 @@ Commands:
                "search" the passages behind it; "get" the whole document.
                "impact" diffs your working tree against a base ref and names the
                runbooks that describe what you changed \u2014 run it after touching a
-               package's exported API or JSDoc, or a Studio surface. A wrong step
+               package's exported API or JSDoc, or a Studio surface. "lint"
+               checks the corpus the other way: every odla-ai command the
+               runbooks name is held against this CLI's real command surface,
+               and against the minimum versions each runbook declares. A wrong step
                is fixed with "edit", which takes effect immediately: a runbook is
                a row, not a release. Runbooks describe PROCEDURE; what an export
                does and what it guarantees is JSDoc, rendered per package at
@@ -6732,6 +6736,124 @@ ${env}: credentials are already saved; retry "odla-ai secrets push --env ${env}$
   }
 }
 
+// src/surface.ts
+var PM_ACTIONS = {
+  list: {},
+  add: {},
+  create: {},
+  get: {},
+  set: {},
+  update: {},
+  status: {},
+  move: {},
+  done: {},
+  comment: {},
+  comments: {},
+  rm: {},
+  delete: {}
+};
+var PM_ENTITIES = Object.fromEntries(
+  ["goal", "conformance", "task", "kanban", "decision", "bug"].map((entity) => [entity, PM_ACTIONS])
+);
+var COMMAND_SURFACE = {
+  admin: {
+    ai: {
+      show: {},
+      set: {},
+      credentials: {},
+      models: {},
+      usage: {},
+      audit: {},
+      credential: { set: {} }
+    }
+  },
+  app: {
+    archive: {},
+    restore: {},
+    export: {},
+    import: {},
+    rename: {},
+    "refresh-sandbox": {},
+    "go-live": {},
+    promote: {},
+    owners: { list: {}, add: {}, remove: {} }
+  },
+  calendar: { status: {}, calendars: {}, connect: {}, disconnect: {} },
+  capabilities: {},
+  code: { connect: {} },
+  doctor: {},
+  help: {},
+  init: {},
+  pm: PM_ENTITIES,
+  provision: {},
+  runbook: {
+    ask: {},
+    search: {},
+    impact: {},
+    list: {},
+    get: {},
+    cat: {},
+    new: {},
+    edit: {},
+    comment: {},
+    import: {},
+    visibility: {},
+    publish: {},
+    archive: {},
+    history: {},
+    revert: {},
+    rm: {},
+    lint: {}
+  },
+  secrets: { push: {}, set: {}, "set-clerk-key": {} },
+  security: {
+    plan: {},
+    sources: {},
+    run: {},
+    status: {},
+    report: {},
+    github: { connect: {}, disconnect: {} }
+  },
+  setup: {},
+  skill: { install: {} },
+  smoke: {},
+  version: {},
+  whoami: {}
+};
+function acceptedAfter(path) {
+  let node = COMMAND_SURFACE;
+  for (const word of path) {
+    node = node?.[word];
+    if (!node) return [];
+  }
+  return Object.keys(node).sort();
+}
+function validateInvocation(words2) {
+  let node = COMMAND_SURFACE;
+  const walked = [];
+  for (const word of words2) {
+    if (Object.keys(node).length === 0) return null;
+    const next = node[word];
+    if (!next) return { validPrefix: walked.join(" "), word, accepted: Object.keys(node).sort() };
+    walked.push(word);
+    node = next;
+  }
+  return null;
+}
+function describeProblem(problem) {
+  const where = problem.validPrefix ? `after "${problem.validPrefix}"` : "as a command";
+  return `"${problem.word}" is not accepted ${where} \u2014 try: ${problem.accepted.join(", ")}`;
+}
+function surfacePaths(node = COMMAND_SURFACE, prefix = []) {
+  const paths = [];
+  for (const [word, child] of Object.entries(node)) {
+    const path = [...prefix, word];
+    paths.push(path);
+    paths.push(...surfacePaths(child, path));
+  }
+  return paths;
+}
+
 // src/security.ts
 import { isAbsolute as isAbsolute5, relative as relative5, resolve as resolve9, sep as sep4 } from "path";
 import {
@@ -8052,6 +8174,55 @@ import process10 from "process";
 
 // src/runbook-actions.ts
 import { readFileSync as readFileSync8 } from "fs";
+
+// src/runbook-requires.ts
+var SPEC = /^(@?[\w./-]+?)@(\d+\.\d+\.\d+(?:[\w.-]*)?)$/;
+function parseRequires(value) {
+  if (!value) return [];
+  const out = [];
+  for (const token of value.split(/[\s,]+/).filter(Boolean)) {
+    const match = SPEC.exec(token);
+    if (match?.[1] && match[2]) out.push({ name: match[1], min: match[2] });
+  }
+  return out;
+}
+function compareVersions(a, b) {
+  const parts = (v) => {
+    const [core = "", pre = ""] = v.split("-", 2);
+    return { nums: core.split(".").map((n) => Number.parseInt(n, 10) || 0), pre };
+  };
+  const left = parts(a);
+  const right = parts(b);
+  for (let i = 0; i < Math.max(left.nums.length, right.nums.length); i++) {
+    const diff = (left.nums[i] ?? 0) - (right.nums[i] ?? 0);
+    if (diff) return diff < 0 ? -1 : 1;
+  }
+  if (left.pre === right.pre) return 0;
+  if (!left.pre) return 1;
+  if (!right.pre) return -1;
+  return left.pre < right.pre ? -1 : 1;
+}
+function satisfies(installed, min) {
+  return compareVersions(installed, min) >= 0;
+}
+function unmetRequirements(requires, installedVersions) {
+  const unmet = [];
+  for (const requirement of parseRequires(requires)) {
+    const installed = installedVersions[requirement.name];
+    if (installed === void 0) {
+      unmet.push({ ...requirement, installed: null });
+    } else if (!satisfies(installed, requirement.min)) {
+      unmet.push({ ...requirement, installed });
+    }
+  }
+  return unmet;
+}
+function describeUnmet(slug, unmet) {
+  const detail = unmet.map((u) => `${u.name}@${u.min}${u.installed ? ` (you have ${u.installed})` : " (not installed here)"}`).join(", ");
+  return `note: runbook "${slug}" expects ${detail} \u2014 some steps may name commands your version does not have.`;
+}
+
+// src/runbook-actions.ts
 var PLATFORM_SCOPE = "$platform";
 async function call(ctx, method, path, body) {
   const res = await ctx.doFetch(`${ctx.platformUrl.replace(/\/$/, "")}/registry/pm${path}`, {
@@ -8106,6 +8277,8 @@ async function runbookList(ctx, all, query) {
 async function runbookGet(ctx, slug) {
   const runbook = await bySlug(ctx, slug);
   if (ctx.json) return ctx.out.log(JSON.stringify(runbook, null, 2));
+  const unmet = unmetRequirements(runbook.requires, { "@odla-ai/cli": cliVersion() });
+  if (unmet.length) ctx.out.error(describeUnmet(slug, unmet));
   ctx.out.log(runbook.body);
 }
 async function runbookNew(ctx, slug, title, body, summary) {
@@ -8525,6 +8698,61 @@ async function runbookImpact(ctx, options, deps = {}) {
   report2(ctx, impacts);
 }
 
+// src/runbook-lint.ts
+function invocationsIn(body) {
+  const re = /(`|npx[^\S\n]+)?(?:@odla-ai\/cli(?:@[\w.-]+)?|odla-ai)((?:[^\S\n]+[a-z][\w-]*)+)/g;
+  const found = [];
+  for (const match of body.matchAll(re)) {
+    if (!match[1]) continue;
+    const words2 = match[2].trim().split(/[^\S\n]+/);
+    if (words2.length) found.push(words2);
+  }
+  return found;
+}
+function lintRunbook(runbook, installed) {
+  const findings = [];
+  const at = { slug: runbook.slug, appId: runbook.appId };
+  const declared = parseRequires(runbook.requires);
+  const seen = /* @__PURE__ */ new Set();
+  for (const words2 of invocationsIn(runbook.body)) {
+    const problem = validateInvocation(words2);
+    if (!problem) continue;
+    const key = `${problem.validPrefix}|${problem.word}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    findings.push({
+      ...at,
+      kind: declared.length ? "command" : "undeclared",
+      detail: declared.length ? `\`odla-ai ${words2.join(" ")}\`: ${describeProblem(problem)}` : `\`odla-ai ${words2.join(" ")}\`: ${describeProblem(problem)}. If a newer package added it, declare that with requires.`
+    });
+  }
+  const unmet = unmetRequirements(runbook.requires, installed);
+  if (unmet.length) findings.push({ ...at, kind: "requires", detail: describeUnmet(runbook.slug, unmet) });
+  return findings;
+}
+async function runbookLint(ctx, all) {
+  const params = new URLSearchParams();
+  if (!all) params.set("app", ctx.appId);
+  const page = await call(ctx, "GET", `/runbook${params.size ? `?${params}` : ""}`);
+  const installed = { "@odla-ai/cli": cliVersion() };
+  const findings = page.records.flatMap((runbook) => lintRunbook(runbook, installed));
+  if (ctx.json) return ctx.out.log(JSON.stringify({ checked: page.records.length, findings }, null, 2));
+  if (!page.records.length) return ctx.out.log("(no runbooks in scope)");
+  if (!findings.length) {
+    return ctx.out.log(
+      `${page.records.length} runbook${page.records.length === 1 ? "" : "s"} checked; every command they name is real for @odla-ai/cli ${cliVersion()}.`
+    );
+  }
+  ctx.out.log(`${findings.length} finding${findings.length === 1 ? "" : "s"} across ${page.records.length} runbooks:`);
+  for (const finding of findings) {
+    const scope = finding.appId === PLATFORM_SCOPE ? "" : ` --app ${finding.appId}`;
+    ctx.out.log("");
+    ctx.out.log(`${finding.slug} [${finding.kind}]`);
+    ctx.out.log(`  ${finding.detail}`);
+    ctx.out.log(`  odla-ai runbook get ${finding.slug}${scope}`);
+  }
+}
+
 // src/runbook-search-command.ts
 async function runbookSearch(ctx, query, all, limit) {
   const params = new URLSearchParams({ q: query });
@@ -8724,7 +8952,7 @@ function requireSlug(slug, action) {
   return slug;
 }
 var WRITES = /* @__PURE__ */ new Set(["new", "edit", "publish", "archive", "visibility", "revert", "rm", "import"]);
-var CONFIG_FREE = /* @__PURE__ */ new Set(["list", "search", "ask", "get", "cat", "history", "impact"]);
+var CONFIG_FREE = /* @__PURE__ */ new Set(["list", "search", "ask", "get", "cat", "history", "impact", "lint"]);
 async function loadOrDefaultConfig(configPath, action, appId) {
   const projectScoped = appId !== void 0;
   if (!projectScoped && CONFIG_FREE.has(action) && !existsSync10(resolve10(configPath))) {
@@ -8806,6 +9034,8 @@ async function runbookCommand(parsed, deps = {}) {
       if (!question) throw new Error('"runbook ask" needs a question, e.g. odla-ai runbook ask "how do I roll back a publish?"');
       return runbookAsk(ctx, question, parsed.options.all === true);
     }
+    case "lint":
+      return runbookLint(ctx, parsed.options.all === true);
     case "impact":
       return runbookImpact(
         ctx,
@@ -8874,9 +9104,7 @@ async function runbookCommand(parsed, deps = {}) {
     case "rm":
       return runbookRemove(ctx, requireSlug(slug, "rm"));
     default:
-      throw new Error(
-        `unknown runbook action "${action}". Try ask, search, impact, list, get, new, edit, comment, import, visibility, publish, archive, history, revert, rm.`
-      );
+      throw new Error(`unknown runbook action "${action}". Try ${acceptedAfter(["runbook"]).join(", ")}.`);
   }
 }
 
@@ -9460,6 +9688,11 @@ export {
   codeConnect,
   runCodeRuntime,
   provision,
+  COMMAND_SURFACE,
+  acceptedAfter,
+  validateInvocation,
+  describeProblem,
+  surfacePaths,
   runHostedSecurity,
   getHostedSecurityIntent,
   getHostedSecurityPlan,
@@ -9472,4 +9705,4 @@ export {
   exitCodeFor,
   runCli
 };
-//# sourceMappingURL=chunk-TOSMNGGQ.js.map
+//# sourceMappingURL=chunk-QMA5OGKQ.js.map