@delorenj/skillex 0.1.2 → 0.2.0

package/dist/commands/bmad.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from "commander";
+import { type ResultEnvelope } from "../index.js";
+interface Output {
+    emit(result: ResultEnvelope<unknown>, text?: string): void;
+    help(command: Command): void;
+}
+/** Register BMAD freeze/status/explain; activation stays an explicit, separate step. */
+export declare function registerBmadCommands(program: Command, output: Output): void;
+export {};

package/dist/core/bmad-freeze.d.ts

@@ -0,0 +1,9 @@
+import type { BmadFreezeData, BmadFreezeOptions } from "./bmad-types.js";
+import { type ResultEnvelope } from "./result.js";
+/**
+ * Freeze the BMAD skills and per-client commands of a BMAD-enabled project into a
+ * versioned reference-only registry pack (ADR-0001). Import is offline, idempotent,
+ * and guarded: same-version repeats change nothing, and a differing existing canonical
+ * body is refused rather than overwritten.
+ */
+export declare function freezeBmadPack(source: string, options?: BmadFreezeOptions): Promise<ResultEnvelope<BmadFreezeData | null>>;

package/dist/core/bmad-source.d.ts

@@ -0,0 +1,40 @@
+import type { BmadCommandInventory, BmadProvenance, BmadSkillManifestEntry } from "./bmad-types.js";
+/** Per-client command layouts discovered on a BMAD-enabled project. Not exhaustive. */
+export declare const BMAD_COMMAND_CLIENTS: ReadonlyArray<{
+    client: string;
+    layout: string;
+}>;
+export declare const BMAD_PACK_NAME = "bmad";
+export declare function sha256File(path: string): Promise<string>;
+/** Expand `~` exactly like other skillex path options; the result must be a real directory. */
+export declare function resolveBmadSource(source: string, options: {
+    cwd?: string;
+}): Promise<string>;
+/** Read the source's own manifests. Entirely offline; nothing is fetched. */
+export declare function inspectBmadSource(sourceRoot: string): Promise<BmadProvenance>;
+/**
+ * Membership source of truth: the source's skill-manifest.csv, reconciled against the
+ * rendered .agents/skills tree. Rendered bmad-* directories absent from the manifest are
+ * inventoried as foreign (installer-owned), never imported silently.
+ */
+export declare function readBmadSkillManifest(sourceRoot: string): Promise<{
+    entries: BmadSkillManifestEntry[];
+    path: string;
+}>;
+export interface BmadCommandScan {
+    readonly inventory: BmadCommandInventory;
+    readonly totalFiles: number;
+    readonly danglingFiles: number;
+}
+export declare function bmadCommandRefs(content: string): string[];
+/**
+ * Copy each client's command layout byte-for-byte. Original assets are preserved; files
+ * whose `_bmad/...` references are dangling in the source install are imported but
+ * reported, never silently rewritten into shims.
+ */
+export declare function scanBmadCommands(sourceRoot: string, packVersionPath: string): Promise<BmadCommandScan>;
+/** Absolute, safe version directory; refuses any traversal outside the pack family. */
+export declare function bmadPackPath(registryRoot: string, version: string): string;
+/** The rendered skill bytes are the only complete source: the source's own tree is pruned. */
+export declare function renderedSkillDir(sourceRoot: string, name: string): string;
+export declare function requireRenderedSkill(sourceRoot: string, name: string): Promise<string>;

package/dist/core/bmad-status.d.ts

@@ -0,0 +1,10 @@
+import type { BmadExplainData, BmadExplainOptions, BmadStatusData, BmadStatusOptions } from "./bmad-types.js";
+import { type ResultEnvelope } from "./result.js";
+/**
+ * Read-only traceability for the BMAD canonical skills present in a registry. Every
+ * frozen BMAD skill is traced against its recorded baseline digest; undeclared pack
+ * children are reported as traceability gaps instead of a misleading green verify.
+ */
+export declare function inspectBmadStatus(options?: BmadStatusOptions): Promise<ResultEnvelope<BmadStatusData | null>>;
+/** Read-only explanation of one canonical BMAD skill: provenance, baseline, references. */
+export declare function explainBmadSkill(name: string, options?: BmadExplainOptions): Promise<ResultEnvelope<BmadExplainData | null>>;

package/dist/core/bmad-types.d.ts

@@ -0,0 +1,150 @@
+import type { CatalogLockOptions } from "./catalog-lock.js";
+import type { RegistryOptions, RegistrySelection } from "./selection.js";
+/** Freeze operates only on real local directories; registry URLs are never fetched. */
+export interface BmadFreezeOptions extends RegistryOptions, CatalogLockOptions {
+    readonly version?: string;
+    readonly dryRun?: boolean;
+    readonly replace?: boolean;
+    readonly commands?: boolean;
+}
+export interface BmadSourceModule {
+    readonly name: string;
+    readonly version: string;
+    readonly source: string | null;
+    readonly repoUrl: string | null;
+    readonly sha: string | null;
+}
+export interface BmadSourceInstallation {
+    readonly version: string;
+    readonly installDate: string | null;
+    readonly lastUpdated: string | null;
+}
+/** Evidence captured offline from the source install's own manifests. */
+export interface BmadProvenance {
+    readonly sourceRoot: string;
+    readonly installation: BmadSourceInstallation;
+    readonly modules: readonly BmadSourceModule[];
+    readonly skillManifestSha256: string | null;
+    readonly filesManifestSha256: string | null;
+    readonly filesManifestDeclared: number;
+    readonly filesManifestMissing: number;
+}
+export type BmadInventoryStatus = "imported" | "unchanged" | "skipped" | "failed";
+export interface BmadSkillInventory {
+    readonly name: string;
+    readonly sourcePath: string;
+    readonly status: BmadInventoryStatus;
+    readonly digest: string | null;
+    readonly recordedDigest: string | null;
+}
+/** Skills installed by the source but outside the frozen manifest, inventoried separately. */
+export interface BmadForeignSkill {
+    readonly name: string;
+    readonly path: string;
+}
+export interface BmadSkillManifestEntry {
+    readonly canonicalId: string;
+    readonly name: string;
+    readonly description: string | null;
+    readonly module: string | null;
+    readonly path: string | null;
+}
+export interface BmadCommandClient {
+    readonly client: string;
+    readonly layout: string;
+    readonly directory: string;
+    readonly imported: number;
+    readonly dangling: number;
+}
+export interface BmadCommandFile {
+    readonly name: string;
+    readonly client: string;
+    readonly layout: string;
+    readonly path: string;
+    readonly sourcePath: string;
+    readonly sha256: string;
+    readonly size: number;
+    readonly bmadRefs: readonly string[];
+    readonly danglingRefs: readonly string[];
+}
+export interface BmadCommandInventory {
+    readonly clients: readonly BmadCommandClient[];
+    readonly files: readonly BmadCommandFile[];
+}
+export interface BmadFreezeChange {
+    readonly action: string;
+    readonly path: string;
+    readonly source?: string;
+}
+export interface BmadFreezeData {
+    readonly registry: RegistrySelection;
+    readonly pack: {
+        readonly name: string;
+        readonly version: string;
+        readonly path: string;
+    };
+    readonly provenance: BmadProvenance;
+    readonly sourceRoot: string;
+    readonly dryRun: boolean;
+    readonly skills: readonly BmadSkillInventory[];
+    readonly foreignSkills: readonly BmadForeignSkill[];
+    readonly skillsDeclared: number;
+    readonly skillsImported: number;
+    readonly skillsUnchanged: number;
+    readonly skillsSkipped: number;
+    readonly skillsFailed: number;
+    readonly commands: BmadCommandInventory;
+    readonly commandFiles: number;
+    readonly danglingCommands: number;
+    readonly changes: readonly BmadFreezeChange[];
+}
+export interface BmadStatusOptions extends RegistryOptions {
+    readonly signal?: {
+        readonly aborted: boolean;
+    };
+}
+export type BmadCanonicalState = "ok" | "missing" | "foreign" | "modified";
+export interface BmadCanonicalStatus {
+    readonly name: string;
+    readonly path: string;
+    readonly state: BmadCanonicalState;
+    readonly digest: string | null;
+    readonly recordedDigest: string | null;
+    readonly references: readonly string[];
+    readonly provenance: Readonly<Record<string, unknown>> | null;
+}
+export interface BmadStatusData {
+    readonly registry: RegistrySelection;
+    readonly skills: readonly BmadCanonicalStatus[];
+    readonly traced: number;
+    readonly drifted: readonly string[];
+    readonly untraced: readonly string[];
+    readonly pack: string | null;
+    readonly packMembers: readonly string[];
+    readonly packVerified: boolean | null;
+    readonly findings: readonly import("./result.js").Diagnostic[];
+}
+export interface BmadExplainOptions extends RegistryOptions {
+    readonly signal?: {
+        readonly aborted: boolean;
+    };
+}
+export interface BmadReference {
+    readonly kind: "pack" | "set" | "skill";
+    readonly name: string;
+    readonly version?: string;
+}
+export interface BmadSkillExplanation {
+    readonly name: string;
+    readonly canonicalPath: string | null;
+    readonly digest: string | null;
+    readonly recordedDigest: string | null;
+    readonly modifiedLocally: boolean | null;
+    readonly bmadVersion: string | null;
+    readonly references: readonly BmadReference[];
+    readonly findings: readonly import("./result.js").Diagnostic[];
+}
+export interface BmadExplainData {
+    readonly registry: RegistrySelection;
+    readonly skill: BmadSkillExplanation;
+}

package/dist/core/profile-policy.d.ts

@@ -0,0 +1,4 @@
+import type { ProfileLocalEntry, ProfileLocation, ProfileOptions } from "./profile-types.js";
+export declare function strictProfile(profile: ProfileLocation, options: ProfileOptions): Promise<boolean>;
+export declare function assertStrictProfile(profile: ProfileLocation, options: ProfileOptions, local: readonly ProfileLocalEntry[]): Promise<boolean>;
+export declare function publishStrictPolicy(profile: ProfileLocation): Promise<void>;

package/dist/core/profile-types.d.ts

@@ -4,6 +4,7 @@ import type { RegistryOptions, SkillOrigin } from "./selection.js";
 export interface ProfileOptions extends RegistryOptions, LockOptions {
     readonly hermesRoot?: string;
     readonly project?: string;
+    readonly skillexOnly?: boolean;
     readonly signal?: {
         readonly aborted: boolean;
     };

package/dist/index.d.ts

@@ -1,5 +1,8 @@
 export { type ReceiptDocument, type ReceiptOptions, type ReceiptSnapshot, readActivationReceipt, validateActivationStateLocation, writeActivationReceipt, } from "./core/activation-state.js";
 export { aliasPaths, GLOBAL_CLI_ALIASES, NEVER_TOUCH, PROJECT_CLI_ALIASES, } from "./core/aliases.js";
+export { freezeBmadPack } from "./core/bmad-freeze.js";
+export { explainBmadSkill, inspectBmadStatus } from "./core/bmad-status.js";
+export type { BmadCanonicalStatus, BmadCommandClient, BmadCommandFile, BmadCommandInventory, BmadExplainData, BmadExplainOptions, BmadForeignSkill, BmadFreezeChange, BmadFreezeData, BmadFreezeOptions, BmadProvenance, BmadReference, BmadSkillExplanation, BmadSkillInventory, BmadSkillManifestEntry, BmadSourceInstallation, BmadSourceModule, BmadStatusData, BmadStatusOptions, } from "./core/bmad-types.js";
 export { listSkills, showSkill } from "./core/catalog.js";
 export type { ListSkillsOptions, SkillDetails, SkillListData, SkillMetadata, SkillReference, SkillShowData, } from "./core/catalog-types.js";
 export { type CatalogChange, type CatalogWriteOptions, type CatalogWriteResult, type CreateSkillOptions, createSkill, importSkill, } from "./core/catalog-write.js";