@delorenj/skillex 0.1.1

package/dist/core/sets.d.ts

@@ -0,0 +1,7 @@
+import type { CompositionMutationData, CompositionOptions, SetListData, SetShowData } from "./composition-types.js";
+import { type ResultEnvelope } from "./result.js";
+export declare function listSets(options?: CompositionOptions): Promise<ResultEnvelope<SetListData | null>>;
+export declare function showSet(name: string, options?: CompositionOptions): Promise<ResultEnvelope<SetShowData | null>>;
+export declare function createSet(name: string, options?: CompositionOptions): Promise<ResultEnvelope<CompositionMutationData | null>>;
+export declare function addSetSkills(name: string, names: readonly string[], options?: CompositionOptions): Promise<ResultEnvelope<CompositionMutationData | null>>;
+export declare function removeSetSkills(name: string, names: readonly string[], options?: CompositionOptions): Promise<ResultEnvelope<CompositionMutationData | null>>;

package/dist/core/vendor-git.d.ts

@@ -0,0 +1,26 @@
+import { type ContentEntry } from "./content.js";
+import type { VendorOptions, VendorSource } from "./vendor-types.js";
+export interface VendorPin {
+    readonly commit: string;
+    readonly refKind: "branch" | "tag" | "commit" | "unknown";
+    readonly committedAt: string;
+    readonly origin?: string;
+}
+export interface VendorGitSkill {
+    readonly name: string;
+    readonly upstreamPath: string;
+    readonly tree: string;
+    readonly digest: string;
+    readonly entries: readonly ContentEntry[];
+    readonly previousProvenance?: Readonly<Record<string, unknown>>;
+}
+export interface VendorGitSource extends VendorPin {
+    readonly source: VendorSource;
+    readonly checkout: string;
+    readonly skills: readonly VendorGitSkill[];
+}
+export declare function vendorInterrupted(options: Pick<VendorOptions, "signal">): void;
+/** Resolve a local commit without checking out files, fetching, or consulting replacement objects. */
+export declare function resolveVendorPin(source: VendorSource, checkoutRoot: string, options?: VendorOptions): Promise<VendorPin>;
+/** Read skill bytes by immutable blob OID; dirty checkout bytes and index state are irrelevant. */
+export declare function readVendorGitSource(source: VendorSource, checkoutRoot: string, options?: VendorOptions): Promise<VendorGitSource>;

package/dist/core/vendor-inspect.d.ts

@@ -0,0 +1,5 @@
+import { type ResultEnvelope } from "./result.js";
+import type { VendorOptions, VendorSourceListResult, VendorSourceShowResult, VendorStatusResult } from "./vendor-types.js";
+export declare function listVendorSources(options?: VendorOptions): Promise<ResultEnvelope<VendorSourceListResult | null>>;
+export declare function showVendorSource(name: string, options?: VendorOptions): Promise<ResultEnvelope<VendorSourceShowResult | null>>;
+export declare function inspectVendorStatus(options?: VendorOptions): Promise<ResultEnvelope<VendorStatusResult | null>>;

package/dist/core/vendor-provenance.d.ts

@@ -0,0 +1,9 @@
+import type { VendorProvenance, VendorProvenanceInput } from "./vendor-types.js";
+/** Parse known fields without treating absence, a local flag, or unknown metadata as ownership. */
+export declare function parseVendorProvenance(raw: Readonly<Record<string, unknown>>, path: string): VendorProvenance;
+export declare function readVendorProvenance(skillPath: string): Promise<VendorProvenance | null>;
+export declare function serializeVendorProvenance(input: VendorProvenanceInput): string;
+/** Python tree wire format: all authored files, root .source.yaml excluded, executable mode included. */
+export declare function digestVendorTree(skillPath: string): Promise<string>;
+/** Preserve C03 imported-link and C07 doctor digest semantics while sharing regular vendored checks. */
+export declare function digestRecordedSkill(skillPath: string, provenance: Pick<VendorProvenance, "type" | "digestFormat">): Promise<string>;

package/dist/core/vendor-sources.d.ts

@@ -0,0 +1,14 @@
+import { type Diagnostic } from "./result.js";
+import type { VendorCheckout, VendorOptions, VendorSource, VendorSourcesManifest } from "./vendor-types.js";
+export declare function checkVendorSignal(options: Pick<VendorOptions, "signal">): void;
+/** Load the owning catalog's declaration only; prepared migration files are never fallback input. */
+export declare function readVendorSources(options?: VendorOptions): Promise<VendorSourcesManifest>;
+/** Internal parser shared with explicit migration of a prepared declaration. */
+export declare function parseVendorSourcesText(text: string, path: string): readonly VendorSource[];
+export declare function selectVendorSources(manifest: VendorSourcesManifest, selected?: readonly string[]): readonly VendorSource[];
+export declare function vendorCheckoutEnvironmentKey(id: string): string;
+export declare function normalizeVendorRepo(repo: string): string;
+/** Directory discovery is separate from Git observation, so list/show remain useful before checkout. */
+export declare function resolveVendorCheckout(source: VendorSource, options?: VendorOptions): Promise<VendorCheckout>;
+/** Stable, bounded text observation; declaration/receipt entries must be real files. */
+export declare function readVendorText(path: string, code: Diagnostic["code"], allowLink?: boolean): Promise<string | null>;

package/dist/core/vendor-state.d.ts

@@ -0,0 +1,54 @@
+import { type BigIntStats } from "node:fs";
+import type { LockOptions } from "./lock.js";
+import type { RegistrySelection } from "./selection.js";
+import type { VendorChange } from "./vendor-types.js";
+export interface VendorIdentity {
+    readonly dev: string;
+    readonly ino: string;
+    readonly uid: string;
+    readonly mode: number;
+    readonly kind: "file" | "directory";
+}
+export interface VendorTreeEvidence {
+    readonly root: VendorIdentity;
+    readonly entries: readonly {
+        readonly path: string;
+        readonly identity: VendorIdentity;
+        readonly hash: string | null;
+    }[];
+}
+export interface VendorOperation {
+    readonly change: VendorChange;
+    readonly stage: string | null;
+    readonly parked: string | null;
+    readonly before: VendorTreeEvidence | null;
+    readonly after: VendorTreeEvidence | null;
+}
+export interface VendorJournal {
+    readonly schema: 1;
+    readonly catalog: string;
+    readonly host: string;
+    readonly uid: string;
+    readonly phase: "preparing" | "ready";
+    readonly operations: readonly VendorOperation[];
+}
+export interface VendorJournalSnapshot {
+    readonly path: string;
+    readonly catalog: string;
+    readonly document: VendorJournal | null;
+}
+export declare function vendorLstat(path: string): Promise<BigIntStats | null>;
+export declare function vendorIdentity(info: BigIntStats): VendorIdentity;
+export declare function assertVendorIdentity(path: string, expected: VendorIdentity): Promise<void>;
+/** Exact evidence includes every authored file, including the provenance receipt. */
+export declare function captureVendorTree(root: string): Promise<VendorTreeEvidence>;
+/** Missing entries are allowed only while cleaning exact parked/prepared recovery trees. */
+export declare function assertVendorTree(root: string, expected: VendorTreeEvidence, allowMissing?: boolean): Promise<void>;
+export declare function removeVendorTree(root: string, expected: VendorTreeEvidence): Promise<void>;
+export declare function readVendorJournal(registry: RegistrySelection, options?: LockOptions): Promise<VendorJournalSnapshot>;
+/** Caller holds the shared catalog lock. Journal publication is atomic and compare-before-write. */
+export declare function writeVendorJournal(previous: VendorJournalSnapshot, document: VendorJournal): Promise<VendorJournalSnapshot>;
+export declare function clearVendorJournal(previous: VendorJournalSnapshot): Promise<void>;
+export declare function newVendorJournal(catalog: string, operations: readonly VendorOperation[], phase?: VendorJournal["phase"]): VendorJournal;
+/** Read-only guard shared by create/import; sync alone can recover under the catalog lock. */
+export declare function assertNoVendorJournal(registry: RegistrySelection, options?: LockOptions): Promise<void>;

package/dist/core/vendor-sync.d.ts

@@ -0,0 +1,4 @@
+import { type ResultEnvelope } from "./result.js";
+import type { VendorSyncOptions, VendorSyncResult } from "./vendor-types.js";
+/** Offline canonical-content writer; composition and activation links are owned by their existing APIs. */
+export declare function syncVendorSources(options?: VendorSyncOptions): Promise<ResultEnvelope<VendorSyncResult | null>>;

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

@@ -0,0 +1,132 @@
+import type { LockOptions } from "./lock.js";
+import type { RegistryOptions, RegistrySelection } from "./selection.js";
+export interface VendorOptions extends RegistryOptions {
+    readonly sources?: readonly string[];
+    readonly checkouts?: Readonly<Record<string, string>>;
+    readonly signal?: {
+        readonly aborted: boolean;
+    };
+    readonly upstream?: boolean;
+    readonly stateHome?: string;
+}
+export interface VendorSyncOptions extends VendorOptions, LockOptions {
+    readonly dryRun?: boolean;
+    readonly adopt?: boolean;
+    readonly discardLocalEdits?: boolean;
+    readonly prune?: boolean;
+}
+export interface VendorSourceSkill {
+    readonly name: string;
+    readonly dir: string;
+}
+export interface VendorSource {
+    readonly name: string;
+    readonly repo: string;
+    readonly version: string;
+    readonly checkout: string;
+    readonly subdir: string;
+    readonly membership: "explicit" | "discovery";
+    readonly skills: readonly VendorSourceSkill[];
+    readonly include: readonly string[];
+    readonly exclude: readonly string[];
+    readonly optional: boolean;
+}
+export interface VendorSourcesManifest {
+    readonly path: string;
+    readonly registry: RegistrySelection;
+    readonly version: 1;
+    readonly sources: readonly VendorSource[];
+}
+export interface VendorCheckout {
+    readonly id: string;
+    readonly root: string | null;
+    readonly source: "argument" | "environment" | "mapping" | "default";
+    readonly searched: readonly string[];
+}
+export interface VendorProvenance {
+    readonly path: string;
+    readonly type: string;
+    readonly source: string | null;
+    readonly upstream: string | null;
+    readonly upstreamVersion: string | null;
+    readonly upstreamCommit: string | null;
+    readonly upstreamTree: string | null;
+    readonly upstreamPath: string | null;
+    readonly extractedAt: string | null;
+    readonly digest: string | null;
+    readonly digestFormat: string | null;
+    readonly modifiedLocally: boolean;
+    readonly raw: Readonly<Record<string, unknown>>;
+}
+export interface VendorProvenanceInput {
+    readonly source: VendorSource;
+    readonly commit: string;
+    readonly tree: string;
+    readonly upstreamPath: string;
+    readonly digest: string;
+    readonly extractedAt: string;
+    readonly previousProvenance?: Readonly<Record<string, unknown>>;
+}
+export interface VendorSkillStatus {
+    readonly name: string;
+    readonly path: string;
+    readonly source: string;
+    readonly state: "ok" | "missing" | "unrecorded" | "invalid" | "modified" | "stale" | "unknown" | "recorded" | "orphaned" | "foreign";
+    readonly recordedCommit: string | null;
+    readonly upstreamCommit: string | null;
+    readonly recordedDigest: string | null;
+    readonly digest: string | null;
+}
+export interface VendorSourceListResult {
+    readonly registry: RegistrySelection;
+    readonly manifest: string;
+    readonly sources: readonly {
+        readonly source: VendorSource;
+        readonly checkout: VendorCheckout;
+    }[];
+}
+export interface VendorSourceShowResult {
+    readonly registry: RegistrySelection;
+    readonly manifest: string;
+    readonly source: VendorSource;
+    readonly checkout: VendorCheckout;
+    readonly membership: "explicit" | "recorded";
+    readonly skills: readonly VendorSkillStatus[];
+}
+export interface VendorStatusResult {
+    readonly registry: RegistrySelection;
+    readonly manifest: string;
+    readonly upstream: boolean;
+    readonly sources: readonly {
+        readonly name: string;
+        readonly membership: "explicit" | "recorded";
+        readonly checkout: VendorCheckout | null;
+        readonly upstreamCommit: string | null;
+    }[];
+    readonly skills: readonly VendorSkillStatus[];
+}
+export interface VendorSourceResolution {
+    readonly name: string;
+    readonly checkout: string | null;
+    readonly commit: string | null;
+    readonly refKind: "branch" | "tag" | "commit" | "unknown" | null;
+    readonly skipped: boolean;
+}
+export interface VendorChange {
+    readonly action: "create" | "update" | "adopt" | "prune" | "unchanged";
+    readonly name: string;
+    readonly source: string;
+    readonly path: string;
+    readonly commit?: string;
+    readonly tree?: string;
+    readonly upstreamPath?: string;
+    readonly digest?: string;
+}
+export interface VendorSyncResult {
+    readonly registry: RegistrySelection;
+    readonly manifest: string;
+    readonly dryRun: boolean;
+    readonly sources: readonly VendorSourceResolution[];
+    readonly changes: readonly VendorChange[];
+    readonly applied: readonly VendorChange[];
+}

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+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 { 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";
+export type { CompositionChange, CompositionDetails, CompositionMutationData, CompositionOptions, PackListData, PackShowData, SetListData, SetShowData, } from "./core/composition-types.js";
+export { explainSkill, inspectStatus } from "./core/diagnostics.js";
+export type { AliasObservation, DiagnosticOptions, ExplainResult, PathObservation, ReceiptObservation, SkillExplanation, SkillObservation, StatusResult, StatusScope, } from "./core/diagnostics-types.js";
+export { discoverRegistry, discoverScopes } from "./core/discovery.js";
+export { doctor } from "./core/doctor.js";
+export type { ConfiguredLegacyWriter, DoctorOptions, DoctorResult, DoctorSourceInspection, DoctorWriterInspection, RunningLegacyWriter, } from "./core/doctor-types.js";
+export { SkillexError } from "./core/error.js";
+export { type LockOptions, withLock } from "./core/lock.js";
+export { isSkillName, isVersionComponent, parseManifest, readManifest } from "./core/manifest.js";
+export { migrate } from "./core/migration.js";
+export type { MigrationItem, MigrationMapping, MigrationOptions, MigrationResult, } from "./core/migration-types.js";
+export { addPackSkills, createPack, listPacks, removePackSkills, showPack, verifyPack, } from "./core/packs.js";
+export type { HermesRootSelection, ProfileCandidate, ProfileChange, ProfileListResult, ProfileLocalEntry, ProfileLocation, ProfileOptions, ProfileShowResult, ProfileSummary, ProfileSyncOptions, ProfileSyncResult, } from "./core/profile-types.js";
+export { listProfiles, showProfile, syncProfile } from "./core/profiles.js";
+export { planSync, sync } from "./core/reconciliation.js";
+export type { SyncChange, SyncOptions, SyncPlan, SyncResult, SyncScopePlan, } from "./core/reconciliation-types.js";
+export { resolveSelection } from "./core/resolution.js";
+export { type Diagnostic, ExitCode, JSON_SCHEMA_VERSION, makeResult, type ResultEnvelope, type ResultOptions, } from "./core/result.js";
+export type { DiscoveryOptions, ExcludedBinding, PackSelection, RegistryOptions, RegistrySelection, Resolution, ResolvedBinding, ResolvedPack, ResolvedScope, ResolveOptions, ScopeDiscovery, ScopeLocation, ScopeName, SetSelection, SkillOrigin, SkillSelection, SkillsManifest, WriteScope, } from "./core/selection.js";
+export type { SelectionChange, SelectionKind, SelectionOptions, SelectionResult, } from "./core/selection-command-types.js";
+export { disableSelection, enableSelection, initScope, setInheritance, } from "./core/selection-commands.js";
+export { readSelectionManifest, type SelectionManifestSnapshot, SelectionManifestWriteError, writeSelectionManifest, } from "./core/selection-manifest.js";
+export { addSetSkills, createSet, listSets, removeSetSkills, showSet } from "./core/sets.js";
+export { inspectVendorStatus, listVendorSources, showVendorSource } from "./core/vendor-inspect.js";
+export { syncVendorSources } from "./core/vendor-sync.js";
+export type { VendorChange, VendorCheckout, VendorOptions, VendorProvenance, VendorProvenanceInput, VendorSkillStatus, VendorSource, VendorSourceListResult, VendorSourceResolution, VendorSourceShowResult, VendorSourceSkill, VendorSourcesManifest, VendorStatusResult, VendorSyncOptions, VendorSyncResult, } from "./core/vendor-types.js";
+export { VERSION } from "./version.js";