@lesliechan721/aw 0.1.0-beta.6 → 0.1.0-beta.60

package/dist/src/commands/status-v6.d.ts

@@ -0,0 +1,279 @@
+import type { CatalogSource, PlatformName, PluginConfigSchemaField, Scope } from '../types.js';
+import { type CodexExtensionKind } from '../utils/codex-surface-analysis.js';
+import { inventoryCatalogSourceReferences } from '../utils/catalog-source-references.js';
+import type { CatalogOperationContext } from '../utils/catalog-operation-context.js';
+import { type NativeCliRunner } from '../utils/native-cli.js';
+import { createCodexNativeObservationSession, type CodexNativeObservationSession } from '../utils/codex-native-observation.js';
+import type { ArtifactCollisionEvidence } from '../utils/ownership.js';
+import { type PluginIntentStateObservation } from '../utils/plugin-intent-state.js';
+import { type SystemCodexInspection } from '../utils/codex-manager.js';
+export interface StatusV8CatalogSource {
+    id: string;
+    identity: string;
+    type: CatalogSource['type'];
+    primary: boolean;
+    requestedRef: string;
+    resolvedCommit?: string;
+    catalogVersion?: string;
+    channel?: string;
+    freshness?: 'active';
+    error?: string;
+    errorCode?: string;
+}
+interface StatusTargetIdentity {
+    pluginName: string;
+    sourceId: string;
+    sourceIdentity: string;
+    pluginId: string;
+    version?: string;
+    platform: PlatformName;
+    cwd: string;
+}
+export interface StatusV8Placement {
+    scope: Scope;
+    state: StatusV8State;
+    components: StatusV8Component[];
+    reasons: StatusV8Reason[];
+    recoveryActions: StatusV8RecoveryAction[];
+}
+export interface StatusV8ClaudeTarget extends StatusTargetIdentity, StatusV8Placement {
+    platform: 'claude';
+}
+export interface StatusV8CodexTarget extends StatusTargetIdentity {
+    platform: 'codex';
+    state: StatusV8State;
+    components: StatusV8Component[];
+    reasons: StatusV8Reason[];
+    recoveryActions: StatusV8RecoveryAction[];
+    placements: StatusV8Placement[];
+}
+export type StatusV8Target = StatusV8ClaudeTarget | StatusV8CodexTarget;
+export interface StatusScopedTarget extends StatusV8Placement {
+    pluginName: string;
+    sourceId: string;
+    sourceIdentity: string;
+    pluginId: string;
+    version?: string;
+    platform: PlatformName;
+    cwd: string;
+    sharedComponents?: StatusV8Component[];
+    sharedReasons?: StatusV8Reason[];
+}
+export declare function statusTargetPlacements(target: StatusV8Target): StatusScopedTarget[];
+export declare function flattenStatusTargets(targets: readonly StatusV8Target[]): StatusScopedTarget[];
+export type StatusV8State = 'absent' | 'ready' | 'needsSync' | 'orphaned' | 'blocked';
+export interface StatusV8RecoveryAction {
+    command: 'sync' | 'cleanup' | 'reinstall' | 'uninstall' | 'manual';
+    scope?: Scope;
+    description: string;
+}
+export type StatusV8DependencyReadinessState = 'ready' | 'absent' | 'blockedByCollision' | 'incomplete' | 'error';
+export interface StatusV8Component {
+    kind: 'intent' | 'ownership' | 'sharedNative' | 'activation' | 'extension' | 'dependency' | 'systemConsumer';
+    key: string;
+    state: string;
+    metadata?: Record<string, string | number | boolean | string[]>;
+}
+export interface StatusV8Reason {
+    code: string;
+    message: string;
+    severity: 'warning' | 'blocking';
+    collision?: ArtifactCollisionEvidence;
+    dependencyPluginId?: string;
+    dependencyPlatform?: PlatformName;
+    dependencyScope?: Scope;
+    dependencyProject?: 'current' | null;
+    rootIssueId?: string;
+    rootIssueCode?: string;
+}
+type StatusOwnershipState = 'present' | 'absent' | 'partial' | 'error';
+export interface StatusSharedNativeProjection {
+    pluginId: string;
+    state: 'missing' | 'usable' | 'replaceable' | 'blocked' | 'unobserved';
+    reason?: 'outdated' | 'damaged' | 'renderDrift' | 'foreign' | 'unreadable';
+    version?: string;
+    desiredVersion?: string;
+    diagnostic?: string;
+    staleCacheObserved?: boolean;
+}
+export declare function projectStatusSharedNativeReasons(sharedNative: StatusSharedNativeProjection | undefined, existingReasonCodes?: readonly string[], desiredEnabled?: boolean): StatusV8Reason[];
+export interface StatusActivationProjection {
+    user?: boolean;
+    project?: boolean;
+    effective?: boolean;
+    evidence: 'observed' | 'assumed' | 'unobserved';
+    systemConsumer?: SystemCodexInspection;
+}
+export interface StatusExtensionProjection {
+    state: 'ready' | 'missing' | 'drifted' | 'conflict';
+    kinds: CodexExtensionKind[];
+}
+export interface StatusIntentProjection {
+    enabled: boolean;
+    scopes: Scope[];
+    relation: 'root' | 'dependency' | 'managed' | 'none';
+}
+type StatusComponentOwner = Pick<StatusV8Target | StatusV8Placement, 'components'> & {
+    sharedComponents?: StatusV8Component[];
+};
+export declare function statusTargetIntent(target: StatusComponentOwner): StatusIntentProjection;
+export declare function statusTargetOwnershipState(target: StatusComponentOwner): StatusOwnershipState;
+export declare function statusTargetSharedNative(target: StatusComponentOwner): StatusSharedNativeProjection | undefined;
+export declare function statusTargetActivation(target: StatusComponentOwner): StatusActivationProjection | undefined;
+export declare function statusTargetExtensions(target: StatusComponentOwner): StatusExtensionProjection | undefined;
+export interface StatusV8Payload {
+    schemaVersion: 8;
+    catalog: {
+        primarySourceId: string;
+        configDigest: string;
+        compositeDigest: string;
+        generationSetDigest?: string;
+        sources: StatusV8CatalogSource[];
+    };
+    filters: {
+        plugins: string[];
+        platform: PlatformName | 'both';
+        scope?: Scope;
+        cwd: string;
+    };
+    targets: StatusV8Target[];
+    configIssues?: Array<NonNullable<StatusV8PluginSummary['configIssues']>[number] & {
+        pluginId: string;
+        pluginName: string;
+    }>;
+    errors: Array<{
+        code: string;
+        message: string;
+    }>;
+}
+export type TargetRevisionState = {
+    state: 'current';
+    availableVersion: string;
+    installedVersion?: string;
+} | {
+    state: 'upgradeAvailable';
+    availableVersion: string;
+    installedVersion?: string;
+} | {
+    state: 'unknown';
+    availableVersion?: string;
+    installedVersion?: string;
+};
+export interface StatusTargetRevision {
+    pluginId: string;
+    platform: PlatformName;
+    scope: Scope;
+    revision: TargetRevisionState;
+}
+export interface StatusV8PluginSummary {
+    pluginName: string;
+    pluginId: string;
+    displayName?: string;
+    description: string;
+    version?: string;
+    supportedTargets?: Record<PlatformName, Scope[]>;
+    configFieldCount?: number;
+    configSchema?: Record<string, PluginConfigSchemaField>;
+    configIssues?: Array<{
+        scope: Scope;
+        type: 'missing-required' | 'invalid-config' | 'sharedCompositeContainsLocalPath' | 'configLayerUnsupported';
+        key: string;
+        title: string;
+        source: 'default' | 'user' | 'project' | 'missing';
+    }>;
+    configDiagnostic?: {
+        scope: Scope;
+        code: 'configReadFailed';
+        message: string;
+    };
+    dependencyDirectCount?: number;
+    dependencyTotalCount?: number;
+    dependencyIssueCount?: number;
+    missingCapabilities?: string[];
+}
+export interface LiveConsoleItem {
+    pluginName: string;
+    version?: string;
+    pluginSummary?: Omit<StatusV8PluginSummary, 'pluginName' | 'pluginId'>;
+    targets: StatusScopedTarget[];
+}
+export interface ConsoleItemsLoadResult {
+    items: LiveConsoleItem[];
+    catalogUnavailable: boolean;
+    status: StatusV8Payload;
+}
+export declare function setStatusDependencyInspectionHookForTests(hook: (() => void) | undefined): void;
+export declare function loadConsoleItemsResult(options?: {
+    cwd?: string;
+    platform?: string;
+    scope?: string;
+    verbose?: boolean;
+}, runtime?: {
+    env?: NodeJS.ProcessEnv;
+}): Promise<ConsoleItemsLoadResult>;
+export declare function loadConsoleItems(options?: {
+    cwd?: string;
+    platform?: string;
+    scope?: string;
+    verbose?: boolean;
+}, runtime?: {
+    env?: NodeJS.ProcessEnv;
+}): Promise<LiveConsoleItem[]>;
+interface DesiredTargetState {
+    scopes: Scope[];
+    relation: 'root' | 'dependency' | 'managed' | 'none';
+}
+export declare function statusRecovery(options: {
+    state: StatusV8State;
+    desired: DesiredTargetState;
+    platform: PlatformName;
+    pluginId: string;
+    dependencyMoves?: Array<{
+        pluginId: string;
+        fromScope: Scope;
+        toScope: Scope;
+    }>;
+    sharedNative?: StatusSharedNativeProjection;
+    scope?: Scope;
+    actualEnabled?: boolean;
+    conflictRoots?: Partial<Record<Scope, string[]>>;
+    errorCodes?: string[];
+}): StatusV8RecoveryAction[];
+export declare function projectTargetRevision(availableVersion: string | undefined, installedVersion: string | undefined): TargetRevisionState;
+declare function statusCommandV8InSession(options: {
+    plugins?: string[];
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    nativeCliRunner?: NativeCliRunner;
+    cliVersion?: string;
+    platform?: string;
+    scope?: string;
+    json?: boolean;
+    verbose?: boolean;
+    catalogOperationContext?: CatalogOperationContext;
+    inventoryCatalogSourceReferences?: typeof inventoryCatalogSourceReferences;
+    codexObservationSession: Awaited<ReturnType<typeof createCodexNativeObservationSession>>;
+}): Promise<{
+    payload: StatusV8Payload;
+    output: string;
+    hasErrors: boolean;
+    pluginSummaries: StatusV8PluginSummary[];
+    targetRevisions: StatusTargetRevision[];
+    projectRoot?: string;
+    projectIntentObservation: PluginIntentStateObservation;
+}>;
+export declare function statusCommandV8(options: {
+    plugins?: string[];
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    nativeCliRunner?: NativeCliRunner;
+    cliVersion?: string;
+    platform?: string;
+    scope?: string;
+    json?: boolean;
+    verbose?: boolean;
+    catalogOperationContext?: CatalogOperationContext;
+    inventoryCatalogSourceReferences?: typeof inventoryCatalogSourceReferences;
+    codexObservationSession?: CodexNativeObservationSession;
+}): ReturnType<typeof statusCommandV8InSession>;
+export {};