@open-agent-toolkit/cli 0.2.35 → 0.2.37

package/dist/commands/tools/shared/pack-inventory.js

@@ -0,0 +1,207 @@
+import { lstat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { compareVersions } from '../../init/tools/shared/version.js';
+import { getAgentVersion, getSkillVersion } from '../../shared/frontmatter.js';
+import { resolveManagedScopeRoots, validateManagedPath, } from '../../../fs/paths.js';
+import { USER_SCOPE_MANAGED_AGENT_FILES, } from '../../../shared/types.js';
+import { digestDirectory, digestFile } from './content-digest.js';
+import { getPackDefinition } from './pack-manifest.js';
+import { readScopedPackIntent, } from './scoped-pack-intent.js';
+async function pathExists(path) {
+    try {
+        await lstat(path);
+        return true;
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+}
+async function inventoryVersionedAsset(definition, installedPath, bundledPath) {
+    const readVersion = definition.kind === 'skill' ? getSkillVersion : getAgentVersion;
+    const [installedVersion, bundledVersion] = await Promise.all([
+        readVersion(installedPath),
+        readVersion(bundledPath),
+    ]);
+    return {
+        definition,
+        path: installedPath,
+        status: compareVersions(installedVersion, bundledVersion),
+        installedVersion,
+        bundledVersion,
+    };
+}
+async function inventoryStaticAsset(definition, installedPath, bundledPath) {
+    const [installedDigest, bundledDigest] = definition.kind === 'directory'
+        ? await Promise.all([
+            digestDirectory(installedPath),
+            digestDirectory(bundledPath),
+        ])
+        : await Promise.all([
+            digestFile(installedPath),
+            digestFile(bundledPath, definition.executable ? 0o755 : undefined),
+        ]);
+    return {
+        definition,
+        path: installedPath,
+        status: installedDigest === bundledDigest ? 'current' : 'outdated',
+        installedVersion: null,
+        bundledVersion: null,
+    };
+}
+async function inventoryAsset(definition, scope, scopeRoot, assetsRoot, managedRoots) {
+    const installedPath = join(scopeRoot, definition.destination);
+    const managedRootName = definition.destination.split('/')[0];
+    if (managedRootName !== '.agents' && managedRootName !== '.oat') {
+        throw new Error(`Pack asset ${definition.id} has unsupported managed root: ${definition.destination}`);
+    }
+    const { realPath } = await validateManagedPath(installedPath, managedRoots[managedRootName]);
+    if (!(await pathExists(realPath))) {
+        return {
+            definition,
+            path: installedPath,
+            status: 'missing',
+            installedVersion: null,
+            bundledVersion: null,
+        };
+    }
+    if (definition.ownership[scope] === 'seed-if-missing') {
+        return {
+            definition,
+            path: installedPath,
+            status: 'present',
+            installedVersion: null,
+            bundledVersion: null,
+        };
+    }
+    if (!definition.source) {
+        throw new Error(`Managed pack asset ${definition.id} has no materialized source`);
+    }
+    const bundledPath = join(assetsRoot, definition.source);
+    if (definition.kind === 'skill' || definition.kind === 'agent') {
+        const inventory = await inventoryVersionedAsset(definition, realPath, bundledPath);
+        return { ...inventory, path: installedPath };
+    }
+    const inventory = await inventoryStaticAsset(definition, realPath, bundledPath);
+    return { ...inventory, path: installedPath };
+}
+function completenessForAssets(assets, scope) {
+    const managed = assets.filter(({ definition }) => definition.ownership[scope] === 'managed');
+    const present = managed.filter(({ status }) => status !== 'missing').length;
+    if (present === 0)
+        return 'absent';
+    return present === managed.length ? 'complete' : 'partial';
+}
+function intentDiagnostic(diagnostic) {
+    return { ...diagnostic };
+}
+/**
+ * User-scope canonical agents are installed into `~/.agents/agents/` but no
+ * provider view is generated for them: `SCOPE_CONTENT_TYPES.user` enumerates
+ * skills only, and the sole user-scope agent materialization is the bundled
+ * managed role file set (`USER_SCOPE_MANAGED_AGENT_FILES`). Completeness alone
+ * therefore reports such a pack as complete while the declared agent surface is
+ * unreachable, so the gap is named here instead of staying silent.
+ */
+function userAgentMaterializationDiagnostics(pack, scope, assets) {
+    if (scope !== 'user')
+        return [];
+    const bundledRoleFiles = new Set(USER_SCOPE_MANAGED_AGENT_FILES);
+    const unmaterialized = assets.filter(({ definition, status }) => definition.kind === 'agent' &&
+        definition.ownership.user === 'managed' &&
+        status !== 'missing' &&
+        !bundledRoleFiles.has(definition.destination.split('/').at(-1) ?? ''));
+    if (unmaterialized.length === 0)
+        return [];
+    return [
+        {
+            code: 'user-agent-unmaterialized',
+            message: `Pack ${pack} installs user-scope canonical agents that no provider view materializes; user-scope agent materialization is limited to the bundled managed role files (${USER_SCOPE_MANAGED_AGENT_FILES.join(', ')}). Install this pack at project scope to make these agents available to providers.`,
+            paths: unmaterialized.map(({ path }) => path),
+        },
+    ];
+}
+export async function inventoryScopedPack(input) {
+    const definition = getPackDefinition(input.pack);
+    if (!definition.allowedScopes.includes(input.scope)) {
+        throw new Error(`Pack ${input.pack} does not allow ${input.scope} scope`);
+    }
+    const applicableAssets = definition.assets.filter(({ scopes }) => scopes.includes(input.scope));
+    const managedRoots = await resolveManagedScopeRoots(input.scopeRoot);
+    const [intent, assets] = await Promise.all([
+        readScopedPackIntent(input),
+        Promise.all(applicableAssets.map((asset) => inventoryAsset(asset, input.scope, input.scopeRoot, input.assetsRoot, managedRoots))),
+    ]);
+    const diagnostics = [
+        ...intent.diagnostics.map(intentDiagnostic),
+        ...userAgentMaterializationDiagnostics(input.pack, input.scope, assets),
+    ];
+    return {
+        pack: input.pack,
+        scope: input.scope,
+        intent,
+        completeness: completenessForAssets(assets, input.scope),
+        assets,
+        diagnostics,
+    };
+}
+export function hasScopedPackPlacementEvidence(inventory) {
+    return (inventory.intent.enabled ||
+        inventory.assets.some(({ definition, status }) => definition.sharedOwner === undefined &&
+            definition.ownership[inventory.scope] === 'managed' &&
+            status !== 'missing'));
+}
+export async function inventoryPack(input) {
+    const definition = getPackDefinition(input.pack);
+    const roots = {
+        project: input.projectRoot,
+        user: input.userRoot,
+    };
+    const scopes = await Promise.all(definition.allowedScopes.flatMap((scope) => {
+        const scopeRoot = roots[scope];
+        return scopeRoot
+            ? [
+                inventoryScopedPack({
+                    pack: input.pack,
+                    scope,
+                    scopeRoot,
+                    assetsRoot: input.assetsRoot,
+                }),
+            ]
+            : [];
+    }));
+    const active = scopes.filter(hasScopedPackPlacementEvidence);
+    const placement = active.length === 2
+        ? 'both'
+        : active[0]?.scope === 'project'
+            ? 'project'
+            : active[0]?.scope === 'user'
+                ? 'user'
+                : 'unavailable';
+    const diagnostics = scopes.flatMap(({ diagnostics: values }) => values);
+    for (const scoped of scopes) {
+        const shared = scoped.assets.filter(({ definition: asset, status }) => asset.sharedOwner !== undefined && status !== 'missing');
+        if (shared.length > 0 && !hasScopedPackPlacementEvidence(scoped)) {
+            diagnostics.push({
+                code: 'shared-owner-observation',
+                message: `Pack ${input.pack} has shared managed assets at ${scoped.scope} scope without pack ownership evidence`,
+                paths: shared.map(({ path }) => path),
+            });
+        }
+    }
+    if (placement === 'both') {
+        const assets = active.flatMap(({ assets: values }) => values.filter(({ status }) => status !== 'missing'));
+        diagnostics.push({
+            code: 'duplicate-scope',
+            message: `Pack ${input.pack} has canonical assets at project and user scope; provider precedence is not inferred`,
+            paths: assets.map(({ path }) => path),
+            versions: assets.map(({ installedVersion }) => installedVersion),
+        });
+    }
+    return { pack: input.pack, placement, scopes, diagnostics };
+}

package/dist/commands/tools/shared/pack-lifecycle.d.ts

@@ -0,0 +1,34 @@
+import type { ConcreteScope } from '../../../shared/types.js';
+import { applyPackReconcilePlan, type ApplyPackReconcileDependencies, type ApplyPackReconcileResult, preflightPackReconcilePlans } from './apply-pack-reconcile.js';
+import { inventoryScopedPack, type ScopedPackInventory } from './pack-inventory.js';
+import { planPackReconcile, type PackReconcileAction, type PackReconcilePlan } from './pack-reconcile.js';
+import type { PackName } from './types.js';
+export interface PackLifecycleRequest {
+    pack: PackName;
+    scope: ConcreteScope;
+    scopeRoot: string;
+    assetsRoot: string;
+    action: PackReconcileAction;
+}
+export interface PackLifecycleResult {
+    request: PackLifecycleRequest;
+    before: ScopedPackInventory;
+    plan: PackReconcilePlan;
+    apply: ApplyPackReconcileResult | null;
+}
+export interface PackLifecycleDependencies {
+    inventory?: typeof inventoryScopedPack;
+    plan?: typeof planPackReconcile;
+    preflight?: typeof preflightPackReconcilePlans;
+    apply?: typeof applyPackReconcilePlan;
+    applyDependencies?: Partial<ApplyPackReconcileDependencies>;
+}
+export declare function reconcilePackLifecycles(requests: readonly PackLifecycleRequest[], options?: {
+    dryRun?: boolean;
+    dependencies?: PackLifecycleDependencies;
+}): Promise<PackLifecycleResult[]>;
+export declare function reconcilePackLifecycle(request: PackLifecycleRequest, options?: {
+    dryRun?: boolean;
+    dependencies?: PackLifecycleDependencies;
+}): Promise<PackLifecycleResult>;
+//# sourceMappingURL=pack-lifecycle.d.ts.map

package/dist/commands/tools/shared/pack-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-lifecycle.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/pack-lifecycle.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EACL,sBAAsB,EACtB,KAAK,8BAA8B,EACnC,KAAK,wBAAwB,EAC7B,2BAA2B,EAC5B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,mBAAmB,EACnB,KAAK,mBAAmB,EACzB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,iBAAiB,EACjB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACvB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,aAAa,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,mBAAmB,CAAC;CAC7B;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,oBAAoB,CAAC;IAC9B,MAAM,EAAE,mBAAmB,CAAC;IAC5B,IAAI,EAAE,iBAAiB,CAAC;IACxB,KAAK,EAAE,wBAAwB,GAAG,IAAI,CAAC;CACxC;AAED,MAAM,WAAW,yBAAyB;IACxC,SAAS,CAAC,EAAE,OAAO,mBAAmB,CAAC;IACvC,IAAI,CAAC,EAAE,OAAO,iBAAiB,CAAC;IAChC,SAAS,CAAC,EAAE,OAAO,2BAA2B,CAAC;IAC/C,KAAK,CAAC,EAAE,OAAO,sBAAsB,CAAC;IACtC,iBAAiB,CAAC,EAAE,OAAO,CAAC,8BAA8B,CAAC,CAAC;CAC7D;AAyBD,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,SAAS,oBAAoB,EAAE,EACzC,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,yBAAyB,CAAC;CACrC,GACL,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAgDhC;AAED,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,oBAAoB,EAC7B,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,yBAAyB,CAAC;CACrC,GACL,OAAO,CAAC,mBAAmB,CAAC,CAE9B"}

package/dist/commands/tools/shared/pack-lifecycle.js

@@ -0,0 +1,67 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { readOatConfig, writeOatConfig } from '../../../config/oat-config.js';
+import { applyPackReconcilePlan, preflightPackReconcilePlans, } from './apply-pack-reconcile.js';
+import { inventoryScopedPack, } from './pack-inventory.js';
+import { planPackReconcile, } from './pack-reconcile.js';
+import { writeScopedPackIntent } from './scoped-pack-intent.js';
+async function writeGenerated(scopeRoot, operation) {
+    await mkdir(dirname(operation.destination), { recursive: true });
+    switch (operation.generation) {
+        case 'projects-root-default':
+            await writeFile(operation.destination, '.oat/projects/shared\n', 'utf8');
+            return;
+        case 'projects-config-default': {
+            const config = await readOatConfig(scopeRoot);
+            if (config.projects?.root?.trim())
+                return;
+            await writeOatConfig(scopeRoot, {
+                ...config,
+                projects: { root: '.oat/projects/shared' },
+            });
+            return;
+        }
+        case 'empty-file':
+            await writeFile(operation.destination, '', 'utf8');
+    }
+}
+export async function reconcilePackLifecycles(requests, options = {}) {
+    const dependencies = options.dependencies ?? {};
+    const inventory = dependencies.inventory ?? inventoryScopedPack;
+    const plan = dependencies.plan ?? planPackReconcile;
+    const planned = await Promise.all(requests.map(async (request) => {
+        const before = await inventory(request);
+        return {
+            request,
+            before,
+            plan: plan({ ...request, inventory: before }),
+            apply: null,
+        };
+    }));
+    if (options.dryRun)
+        return planned;
+    await (dependencies.preflight ?? preflightPackReconcilePlans)(planned.map(({ request, plan: value }) => ({
+        plan: value,
+        scopeRoot: request.scopeRoot,
+    })));
+    const results = [];
+    for (const entry of planned) {
+        const request = entry.request;
+        const applied = await (dependencies.apply ?? applyPackReconcilePlan)(entry.plan, request.scopeRoot, {
+            ...dependencies.applyDependencies,
+            writeGenerated: async (operation) => writeGenerated(request.scopeRoot, operation),
+            writeIntent: async (operation) => writeScopedPackIntent({
+                pack: operation.pack,
+                scope: operation.scope,
+                scopeRoot: request.scopeRoot,
+                enabled: operation.enabled,
+            }),
+            inventory: async () => inventory(request),
+        });
+        results.push({ ...entry, apply: applied });
+    }
+    return results;
+}
+export async function reconcilePackLifecycle(request, options = {}) {
+    return (await reconcilePackLifecycles([request], options))[0];
+}

package/dist/commands/tools/shared/pack-manifest.d.ts

@@ -0,0 +1,11 @@
+import type { PackAssetDefinition, PackAssetGeneration, PackAssetKind, PackAssetOwnership, PackDefinition, PackName } from './types.js';
+export type { PackAssetDefinition, PackAssetGeneration, PackAssetKind, PackAssetOwnership, PackDefinition, };
+export declare const PACK_NAMES: readonly ["core", "ideas", "docs", "workflows", "utility", "project-management", "research", "brainstorm"];
+export declare function isPackName(value: string): value is PackName;
+export declare const PACK_MANIFEST: readonly PackDefinition[];
+export declare function getPackDefinition(pack: PackName): PackDefinition;
+export declare function getPackAssets(pack: PackName, kind?: PackAssetKind): readonly PackAssetDefinition[];
+export declare function getPackMemberNames(pack: PackName, kind: 'skill' | 'agent' | 'template' | 'script'): string[];
+export declare function getCanonicalProviderPaths(pack: PackName): string[];
+export declare function validatePackManifest(manifest?: readonly PackDefinition[]): void;
+//# sourceMappingURL=pack-manifest.d.ts.map

package/dist/commands/tools/shared/pack-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-manifest.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/pack-manifest.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,mBAAmB,EACnB,mBAAmB,EACnB,aAAa,EACb,kBAAkB,EAClB,cAAc,EACd,QAAQ,EACT,MAAM,SAAS,CAAC;AAEjB,YAAY,EACV,mBAAmB,EACnB,mBAAmB,EACnB,aAAa,EACb,kBAAkB,EAClB,cAAc,GACf,CAAC;AAEF,eAAO,MAAM,UAAU,4GASiB,CAAC;AAEzC,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,QAAQ,CAE3D;AA8HD,eAAO,MAAM,aAAa,EAAE,SAAS,cAAc,EAwKlD,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,GAAG,cAAc,CAMhE;AAED,wBAAgB,aAAa,CAC3B,IAAI,EAAE,QAAQ,EACd,IAAI,CAAC,EAAE,aAAa,GACnB,SAAS,mBAAmB,EAAE,CAGhC;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,UAAU,GAAG,QAAQ,GAC9C,MAAM,EAAE,CAQV;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CAIlE;AA0DD,wBAAgB,oBAAoB,CAClC,QAAQ,GAAE,SAAS,cAAc,EAAkB,GAClD,IAAI,CA6DN"}