@vibe-agent-toolkit/cli 0.2.0-rc.10 → 0.2.0-rc.12

package/dist/commands/skills/validate.d.ts

@@ -3,13 +3,20 @@
  *
  * Discovers skills from config yaml skills.include/exclude, validates each
  * using validateSkillForPackaging with merged packaging config.
+ *
+ * Publishes the `Report<T>` envelope (`validate-schema.ts`): every finding
+ * flat with its `location` relative to `data.root`, one `data.skills` row per
+ * skill validated, `examined` = skills validated. A run over zero skills is
+ * refused by the writer, from the registry's declared denominator — never by
+ * a check at this site. `--verbose` decides only how much stderr prints.
  */
 import { type DeclaredEvalSuite, type PackagingValidationResult, type SkillPackagingConfig, type SkillValidationSharedContext } from '@vibe-agent-toolkit/agent-skills';
 import { ResourceRegistry, type ProjectConfig, type ResourcePopulationSource, type SkillsConfig } from '@vibe-agent-toolkit/resources';
-import { type SeverityCounts, type ValidationIssue } from '@vibe-agent-toolkit/schema';
+import { type ValidationIssue } from '@vibe-agent-toolkit/schema';
 import { type createLogger } from '../../utils/logger.js';
-import { type PhaseOutcome } from '../phase-utils.js';
+import type { PhaseOutcome } from '../phase-utils.js';
 import { type DiscoveredSkill } from './command-helpers.js';
+import type { SkillsValidateReport } from './validate-schema.js';
 /**
  * Skills validate command options
  */
@@ -24,145 +31,85 @@ export interface SkillsValidateCommandOptions {
 export interface ValidatableSkill extends DiscoveredSkill {
     packagingConfig: SkillPackagingConfig;
 }
-/** The vocabulary of a validation verdict: worst ACTIONABLE severity. */
-type ValidationStatus = 'success' | 'warning' | 'error';
 /**
- * Findings about the RUN rather than about any one skill — currently the
- * `validation.allow` entries no skill in the batch matched (ALLOW_UNUSED).
- *
- * They are a separate parameter, not folded into a skill's result, because
- * that is what they are: `validation.allow` is declared once per package, so
- * attributing "nothing matched this entry" to whichever skill happened to be
- * validated at the time is what produced 78 warnings from 3 real entries.
+ * The discovery globs that decided which skills a run validated — named on
+ * stderr when they matched nothing ({@link nothingDiscoveredLine}); the
+ * document carries only the registry's generic `whenZero`. Only these two keys
+ * are read, so a full `SkillsConfig` and a test's two arrays hand in the same thing.
  */
-type RunIssues = readonly ValidationIssue[];
-/**
- * The discovery declaration a run's document answers for: the globs that
- * decided which skills it validated. Only these two keys are read, so a caller
- * with a full `SkillsConfig` and a test with two arrays hand in the same thing.
- */
-export type SkillDiscoveryPatterns = Pick<SkillsConfig, 'include' | 'exclude'>;
+type SkillDiscoveryPatterns = Pick<SkillsConfig, 'include' | 'exclude'>;
+/** What {@link buildSkillsValidateReport} needs — the run's results, nothing it has to go and read. */
+interface SkillsValidateInput {
+    /** The directory the config was read from: the ONE base every `location` is relative to. */
+    readonly root: string;
+    /** One result per skill the run validated: the denominator. */
+    readonly results: readonly PackagingValidationResult[];
+    /**
+     * Findings about the RUN rather than about any one skill — the
+     * `validation.allow` entries no skill in the batch matched (ALLOW_UNUSED).
+     * `validation.allow` is declared once per package, so attributing "nothing
+     * matched this entry" to whichever skill happened to be validated at the
+     * time is what produced 78 warnings from 3 real entries.
+     */
+    readonly runIssues: readonly ValidationIssue[];
+    readonly durationMs: number;
+}
 /**
- * The run-level findings, with the run-integrity refusal derived in front of
- * them when the run validated no skill.
- *
- * 🚨 **Zero skills validated is an ERROR, not a clean run.** `skills.include`
- * globs that discover nothing — a typo, a renamed directory, an `exclude` that
- * swallows every match — used to take an early return that printed one info
- * line and published NO document at exit 0, and `vat validate` folded that into
- * `status: success`: the gate the docs name as THE gate, green forever on a
- * config that checked nothing. `vat verify` refused the identical config in its
- * `packaged-content` phase and its message sent the operator to this command,
- * which then said nothing.
- *
- * 🔑 The ONE seam both channels read. {@link buildValidateSummary} (the
- * document) and {@link formatValidationReportLines} (stderr) both derive their
- * issue set here, so "denominator zero, status clean" is unrepresentable on
- * either channel rather than merely unwritten, and the exit code — derived from
- * the document's own counts — agrees with both by construction. Through the
- * shared mechanism in `run-integrity.ts`: one non-overridable
- * `RESOURCE_CHECK_BROKEN` at `error`.
- *
- * Only the empty GLOB is refused. A config with no `skills:` block at all is a
- * choice — the project declares no skills — and both orchestrators already skip
- * this phase on that config; the phase declines it the same way (no document,
- * exit 0) rather than inventing a refusal for a gate nobody declared.
- *
- * @param results - One result per skill the run validated: the denominator
- * @param runIssues - The run's own findings so far (`ALLOW_UNUSED`), so an
- *   existing run-integrity report is not duplicated
- * @param patterns - The discovery globs, named in the refusal so the operator
- *   sees what matched nothing
- * @returns The run-level issues the document and the stderr report publish
+ * Build the report. Pure: no file system, no clock, no `process.exit`.
+ *
+ * Every finding is on the envelope, flat — each skill's, then the run's — so
+ * the envelope `summary` is exactly the sum of the `data.skills[].summary`
+ * rows plus the run-level findings, by construction. Every validated skill has
+ * a row, clean or not: `examined` and `data.skills.length` agree, so a reader
+ * never has to guess whether an absent skill was clean or never validated.
+ *
+ * The run-integrity refusal for a run over zero skills is NOT decided here;
+ * the writer adds it from the registry's declared denominator.
+ *
+ * @param input - The run's results
+ * @returns The report, before the writer's run-integrity pass
  */
-export declare function withRunIntegrity(results: readonly PackagingValidationResult[], runIssues: RunIssues, patterns: SkillDiscoveryPatterns): ValidationIssue[];
+export declare function buildSkillsValidateReport(input: SkillsValidateInput): SkillsValidateReport;
 /**
- * Build the YAML summary object.
- *
- * `status` is the shared `issues → status` collapse over the WHOLE batch, so it
- * can say `warning`. It previously read
- * `results.some(r => r.status === 'error') ? 'error' : 'success'` — a two-value
- * collapse that could never report the warning case, and so reported 33 active
- * warnings as `success`.
- *
- * The header total counts BOTH the per-skill findings and the run-level ones,
- * because the exit code does too — dropping run issues from the header would
- * divorce the published verdict from the code the process actually returns.
- * That is why `runIssueCounts` exists beside them: on a large real repo the
- * header read 1814 warnings against a per-skill sum of 1800, and the missing 14
- * were run-level ALLOW_UNUSED entries published only as a bare LIST. The
- * identity `issueCounts === Σ results[].issueCounts + runIssueCounts` now holds
- * by construction, so a consumer can reconcile the two numbers instead of
- * hand-counting a list to find out whether anything went missing.
- *
- * That identity survives the default mode dropping every finding-free skill from
- * `results[]`, because a dropped row contributes exactly zero to each bucket —
- * and it survives the default row publishing its counts flat with zero buckets
- * omitted, because an absent bucket reads as zero. Only the per-asset ROWS omit
- * zeros: `issueCounts` and `runIssueCounts` keep their complete
- * `{errors, warnings, info}` shape in both modes, because they are the
- * reconciliation identity rather than something a reader scans.
- *
- * A run over ZERO skills is refused here, not passed — see
- * {@link withRunIntegrity}, which is why the discovery `patterns` are a
- * parameter of a document builder: the refusal names the globs that matched
- * nothing, and the builder is where the refusal is derived.
+ * The stderr half of a run over zero skills: WHICH globs matched nothing.
+ *
+ * The document's refusal is the registry's generic `whenZero` — the writer
+ * cannot see the config — so the globs this run actually used are named here,
+ * where the operator reads them.
  */
-export declare function buildValidateSummary(results: PackagingValidationResult[], duration: number, verbose: boolean, runIssues: RunIssues, patterns: SkillDiscoveryPatterns): {
-    status: ValidationStatus;
-    issueCounts: SeverityCounts;
-    runIssueCounts: SeverityCounts;
-    skillsValidated: number;
-    results: unknown[];
-    runIssues: ValidationIssue[];
-    durationSecs: number;
-};
+export declare function nothingDiscoveredLine(patterns: SkillDiscoveryPatterns | undefined): string;
 /**
  * Human-readable report lines for the whole batch.
  *
- * Renders every skill with ANY emitted finding, not just the ones that failed
- * the gate: a warning-only or info-only run used to print the success banner and
+ * Renders every skill with ANY finding, not just the ones that failed the
+ * gate: a warning-only or info-only run used to print the success banner and
  * nothing else, so the findings existed only in the YAML on stdout.
  *
  * Every skill with findings gets its summary row at every verbosity; `verbose`
  * picks only which findings are ALSO rendered in full beneath that row, per
  * {@link issuesToRenderAtVerbosity} — errors always, `warning`/`info` when
- * asked, `ignore` never. `verbose` deliberately does NOT gate errors: a default
- * run that collapsed the error it exited 1 on into a count line forced the reader
- * to re-run with a flag to learn what broke.
+ * asked, `ignore` never.
  *
- * Run-level findings and the banner are printed in full either way — there are
- * ~14 of the former, and they belong to the project config rather than to any
- * asset, so there is no row for them to collapse into.
+ * `runFindings` are the published run-level findings — the `validation.allow`
+ * entries no skill matched, and the writer's run-integrity refusal when the
+ * run validated nothing — so the banner counts what the document counts and a
+ * run over zero skills cannot print a green banner over a refused document.
  *
- * Reads the same seam as the document builder ({@link withRunIntegrity}), so a
- * run over zero skills prints the refusal here too rather than a green banner
- * over a document that says `error`.
+ * @param results - One result per skill validated
+ * @param runFindings - The run-level findings the document published
+ * @param examined - The published report's `examined`, never recounted
+ * @param verbose - Render every finding in full, and the per-skill detail
  */
-export declare function formatValidationReportLines(results: PackagingValidationResult[], runIssues: RunIssues, verbose: boolean, patterns: SkillDiscoveryPatterns): string[];
+export declare function formatValidationReportLines(results: readonly PackagingValidationResult[], runFindings: readonly ValidationIssue[], examined: number, verbose: boolean): string[];
 /**
  * Log validation progress for a single skill.
  *
- * The per-skill glyph follows the shared collapse (`⚠️` for a warning-only
- * skill), and the severity breakdown is always spelled out. A skill with
- * warnings used to print a bare `✅ <name>`, which is the same reassuring
- * collapse as the batch banner, one line earlier.
+ * The per-skill glyph follows the skill's worst severity (`⚠️` for a
+ * warning-only skill), and the severity breakdown is always spelled out. A
+ * skill with warnings used to print a bare `✅ <name>`, which is the same
+ * reassuring collapse as the batch banner, one line earlier.
  */
 export declare function formatSkillProgressLine(skillName: string, result: PackagingValidationResult): string[];
-/**
- * Build a single shared validation context for an entire `vat skills validate`
- * invocation.
- *
- * When every skill in the batch resolves to the same projectRoot (the normal
- * monorepo case), we crawl the resource registry once and hand the same
- * instance to each skill's validation — the per-skill markdown reparse
- * disappears. Similarly, gitignore checks are backed by a single
- * {@link GitTracker} when every skill sits inside the same git repository.
- *
- * When the batch is heterogeneous (e.g. multiple projectRoots), the helper
- * returns an empty context and validators transparently fall back to their
- * legacy per-skill setup — correctness first, perf second.
- */
 /**
  * Options for {@link buildSkillsValidateRegistry}.
  */
@@ -205,25 +152,42 @@ export interface SkillsValidateRegistryOptions {
  * @returns A crawled registry whose links are already resolved
  */
 export declare function buildSkillsValidateRegistry(projectRoot: string, options?: SkillsValidateRegistryOptions): Promise<ResourceRegistry>;
+/**
+ * Build a single shared validation context for an entire `vat skills validate`
+ * invocation.
+ *
+ * When every skill in the batch resolves to the same projectRoot (the normal
+ * monorepo case), we crawl the resource registry once and hand the same
+ * instance to each skill's validation — the per-skill markdown reparse
+ * disappears. Similarly, gitignore checks are backed by a single
+ * {@link GitTracker} when every skill sits inside the same git repository.
+ *
+ * When the batch is heterogeneous (e.g. multiple projectRoots), the helper
+ * returns an empty context and validators transparently fall back to their
+ * legacy per-skill setup — correctness first, perf second.
+ */
 export declare function buildSharedValidationContext(skills: ValidatableSkill[], projectSkills: readonly DeclaredEvalSuite[], config: ProjectConfig | undefined, logger: ReturnType<typeof createLogger>): Promise<SkillValidationSharedContext>;
 /**
- * Validate every configured skill and hand back the document and exit code,
- * printing the document nowhere.
- *
- * The phase entry point for `vat validate` and `vat verify`. The one early
- * return publishes NO document: a config with no `skills:` block prints one
- * info line, exits 0, and `phaseResultFromOutcome` records that as `success`
- * with no `report` — both orchestrators skip the phase on that config anyway,
- * because declaring no skills is a choice.
- *
- * A `skills:` block whose globs discover nothing is NOT a second early return.
- * It used to be — one info line, no document, exit 0 — and that made `vat
- * validate` green forever on a typo'd glob. It now runs through the same
- * builder as a populated batch, which refuses a zero denominator (see
- * {@link withRunIntegrity}): a document with one `RESOURCE_CHECK_BROKEN` at
- * `error`, `status: error`, exit 1. Exit 1 and not 2, deliberately: the run
- * completed and the gate FAILED, which is the class an operator's CI already
- * handles; 2 is for a run that could not answer at all.
+ * Validate every configured skill and hand back the report, printing it
+ * nowhere.
+ *
+ * The phase entry point for `vat validate` and `vat verify`, and the command's
+ * own. The report is the one BEFORE the writer's run-integrity pass: inside an
+ * orchestrator, `runPhase` applies the same pass to this phase's report, by the
+ * declaration this verb gives its own writer.
+ *
+ * A run that validated no skill — globs that discover nothing, or a config
+ * with no `skills:` block — is not a clean run. It used to take an early
+ * return that printed one info line and published NO document at exit 0, and
+ * `vat validate` folded that into success: the gate the docs name as THE gate,
+ * green forever on a config that checked nothing. Now it reports zero skills,
+ * which the writer refuses with `RESOURCE_CHECK_BROKEN` (exit 1) when this is
+ * the whole run; stderr names the globs that matched nothing. Both
+ * orchestrators skip this phase for a config with no `skills:` block.
+ *
+ * Every refusal is classified by code: a `[path]` naming nothing, an unknown
+ * `--skill`, no project root → `USAGE_INVALID`; an unlistable directory →
+ * `INPUT_UNREADABLE`; a config that does not parse → `CONFIG_INVALID`.
  */
 export declare function runSkillsValidatePhase(pathArg: string | undefined, options: SkillsValidateCommandOptions): Promise<PhaseOutcome>;
 /**

package/dist/commands/skills/validate.d.ts.map

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