thoth-agents 0.1.6 → 0.1.7

package/dist/cli/operations/codex.d.ts

@@ -0,0 +1,22 @@
+import type { CodexInstallScope } from '../codex-paths';
+import type { HarnessAction, HarnessStatusReport, ModelConfigInput, OperationApplyResult, OperationContext, OperationPlan } from './types';
+export interface CodexOperationContext extends OperationContext {
+    scope?: CodexInstallScope;
+    homeDir?: string;
+    codexHome?: string;
+    packageRoot?: string;
+    pluginId?: string;
+}
+export declare const codexOperationAdapter: {
+    readonly id: "codex";
+    readonly displayName: "Codex";
+    readonly available: true;
+    readonly description: "Codex agent-pack and managed subagent surfaces.";
+    readonly actions: HarnessAction[];
+};
+export declare function getCodexStatus(context?: CodexOperationContext): HarnessStatusReport;
+export declare function buildCodexUpdatePlan(context?: CodexOperationContext): OperationPlan;
+export declare function buildCodexSyncPlan(context?: CodexOperationContext): OperationPlan;
+export declare function buildCodexInstallPlan(context?: CodexOperationContext): OperationPlan;
+export declare function buildCodexModelPlan(input: ModelConfigInput, context?: CodexOperationContext): OperationPlan;
+export declare function applyCodexPlan(plan: OperationPlan): OperationApplyResult;

package/dist/cli/operations/index.d.ts

@@ -0,0 +1,8 @@
+import type { HarnessId } from '../../harness/types';
+import type { HarnessOperationAdapter, OperationHarnessMetadata } from './types';
+export declare const SUPPORTED_OPERATION_HARNESSES: HarnessId[];
+export declare function isSupportedOperationHarness(value: string): value is HarnessId;
+export declare function listOperationHarnesses(): HarnessOperationAdapter[];
+export declare function getOperationHarness(harness: HarnessId): HarnessOperationAdapter;
+export declare function resolveOperationHarness(harness: string): OperationHarnessMetadata;
+export type { BackupExpectation, BackupStrategy, HarnessAction, HarnessOperationAdapter, HarnessStatusReport, ManagedState, ManagedSurface, ManagedTarget, ManagedTargetKind, ModelConfigInput, ModelRoleInput, OperationApplyResult, OperationContext, OperationDisclaimer, OperationHarnessMetadata, OperationPath, OperationPlan, OperationPlanItem, OperationWarning, WarningSeverity, } from './types';

package/dist/cli/operations/opencode.d.ts

@@ -0,0 +1,14 @@
+import type { HarnessAction, HarnessStatusReport, ModelConfigInput, OperationApplyResult, OperationContext, OperationPlan } from './types';
+export declare const opencodeOperationAdapter: {
+    readonly id: "opencode";
+    readonly displayName: "OpenCode";
+    readonly available: true;
+    readonly description: "OpenCode plugin and configuration surfaces.";
+    readonly actions: HarnessAction[];
+};
+export declare function getOpenCodeStatus(context?: OperationContext): HarnessStatusReport;
+export declare function buildOpenCodeUpdatePlan(_context?: OperationContext): OperationPlan;
+export declare function buildOpenCodeSyncPlan(_context?: OperationContext): OperationPlan;
+export declare function buildOpenCodeInstallPlan(_context?: OperationContext): OperationPlan;
+export declare function buildOpenCodeModelPlan(input: ModelConfigInput, _context?: OperationContext): OperationPlan;
+export declare function applyOpenCodePlan(plan: OperationPlan): OperationApplyResult;

package/dist/cli/operations/types.d.ts

@@ -0,0 +1,126 @@
+import type { HarnessId } from '../../harness/types';
+export type ManagedState = 'installed' | 'missing' | 'drift' | 'outdated' | 'unknown';
+export type OperationActionKind = 'status' | 'list' | 'install' | 'update' | 'sync' | 'repair' | 'model-config';
+export type ManagedTargetKind = 'file' | 'directory' | 'config' | 'skill' | 'hook' | 'memory-state' | 'generated-artifact' | 'package' | 'surface' | 'unknown';
+export type WarningSeverity = 'minor' | 'important' | 'critical';
+export interface OperationPath {
+    path: string;
+    label?: string;
+}
+export interface OperationWarning {
+    severity: WarningSeverity;
+    message: string;
+    code?: string;
+}
+export interface OperationDisclaimer {
+    message: string;
+    code?: string;
+}
+export interface ManagedTarget {
+    kind: ManagedTargetKind;
+    path?: string;
+    label?: string;
+    state?: ManagedState;
+    expected?: string;
+    observed?: string;
+    description?: string;
+}
+export interface ManagedSurface {
+    id: string;
+    label: string;
+    state?: ManagedState;
+    path?: string;
+    description?: string;
+}
+export interface HarnessAction {
+    id: string;
+    kind: OperationActionKind;
+    label: string;
+    description: string;
+    dryRun: boolean;
+    requiresConfirmation: boolean;
+    supported?: boolean;
+    disabledReason?: string;
+    warnings?: OperationWarning[];
+    disclaimers?: OperationDisclaimer[];
+}
+export interface HarnessStatusReport {
+    harness: HarnessId;
+    displayName?: string;
+    state: ManagedState;
+    summary: string;
+    targets: ManagedTarget[];
+    diagnostics: OperationWarning[];
+    actions: HarnessAction[];
+    disclaimers?: OperationDisclaimer[];
+}
+export type BackupStrategy = 'none' | 'managed-backup-file' | 'existing-helper' | 'external';
+export interface BackupExpectation {
+    required: boolean;
+    strategy: BackupStrategy;
+    destinations?: OperationPath[];
+    description?: string;
+}
+export interface OperationPlanItem {
+    title: string;
+    target: ManagedTarget;
+    state?: ManagedState;
+    preview?: string;
+    backup?: BackupExpectation;
+    warnings?: OperationWarning[];
+    disclaimers?: OperationDisclaimer[];
+}
+export interface OperationPlan {
+    id: string;
+    harness: HarnessId;
+    action: OperationActionKind;
+    title: string;
+    summary: string;
+    dryRun: boolean;
+    canApply: boolean;
+    targets: ManagedTarget[];
+    surfaces: ManagedSurface[];
+    backup: BackupExpectation;
+    items: OperationPlanItem[];
+    warnings: OperationWarning[];
+    disclaimers: OperationDisclaimer[];
+}
+export interface ModelRoleInput {
+    role: string;
+    model: string;
+    provider?: string;
+}
+export interface ModelConfigInput {
+    harness: HarnessId;
+    roles: ModelRoleInput[];
+    dryRun: boolean;
+    target?: ManagedTarget;
+    warnings?: OperationWarning[];
+    disclaimers?: OperationDisclaimer[];
+}
+export interface OperationApplyResult {
+    harness: HarnessId;
+    action: OperationActionKind;
+    applied: boolean;
+    summary: string;
+    changedTargets: ManagedTarget[];
+    backups: OperationPath[];
+    warnings: OperationWarning[];
+    disclaimers: OperationDisclaimer[];
+}
+export interface OperationContext {
+    cwd: string;
+    env?: Readonly<Record<string, string | undefined>>;
+}
+export interface OperationHarnessMetadata {
+    id: HarnessId | string;
+    displayName: string;
+    available: boolean;
+    description: string;
+    actions: HarnessAction[];
+    reason?: string;
+}
+export interface HarnessOperationAdapter extends OperationHarnessMetadata {
+    id: HarnessId;
+    available: true;
+}

package/dist/cli/parser.d.ts

@@ -0,0 +1,6 @@
+import { type RuntimeContext } from './runtime';
+import type { CliParseResult, InstallArgs, OperationArgs } from './types';
+export declare function parseOperationArgs(args: string[]): OperationArgs;
+export declare function parseInstallArgs(args: string[]): InstallArgs;
+export declare function parseGenerateArgs(args: string[]): CliParseResult;
+export declare function parseCliArgs(args: string[], runtimeContext?: RuntimeContext): CliParseResult;

package/dist/cli/runtime.d.ts

@@ -0,0 +1,21 @@
+export interface RuntimeContext {
+    stdinIsTTY: boolean;
+    stdoutIsTTY: boolean;
+    stderrIsTTY?: boolean;
+    env: Record<string, string | undefined>;
+}
+interface ProcessLike {
+    stdin?: {
+        isTTY?: boolean;
+    };
+    stdout?: {
+        isTTY?: boolean;
+    };
+    stderr?: {
+        isTTY?: boolean;
+    };
+    env?: Record<string, string | undefined>;
+}
+export declare function detectRuntimeContext(processLike?: ProcessLike): RuntimeContext;
+export declare function isInteractiveRuntime(context: RuntimeContext): boolean;
+export {};

package/dist/cli/skills.d.ts

@@ -13,14 +13,31 @@ export interface RecommendedSkill {
     /** Optional commands to run after the skill is added */
     postInstallCommands?: string[];
 }
+export type RecommendedSkillInstallStatus = 'installed' | 'already-installed' | 'failed';
+export interface RecommendedSkillInstallResult {
+    skill: RecommendedSkill;
+    status: RecommendedSkillInstallStatus;
+    skillPath: string;
+    error?: unknown;
+}
+interface InstallRecommendedSkillOptions {
+    homeDir?: string;
+}
 /**
  * List of recommended skills.
  * Add new skills here to include them in the installation flow.
  */
 export declare const RECOMMENDED_SKILLS: RecommendedSkill[];
+export declare function getRecommendedSkillPath(skill: RecommendedSkill, homeDir?: string): string;
+export declare function isRecommendedSkillInstalled(skill: RecommendedSkill, options?: InstallRecommendedSkillOptions): boolean;
+/**
+ * Install a recommended OpenCode skill with idempotent semantics.
+ */
+export declare function installRecommendedSkill(skill: RecommendedSkill, options?: InstallRecommendedSkillOptions): RecommendedSkillInstallResult;
 /**
  * Install a skill using `npx skills add`.
  * @param skill - The skill to install
  * @returns True if installation succeeded, false otherwise
  */
 export declare function installSkill(skill: RecommendedSkill): boolean;
+export {};

package/dist/cli/tui/App.d.ts

@@ -0,0 +1,7 @@
+import { type TuiOperations } from './operations';
+interface AppProps {
+    operations?: TuiOperations;
+    exitOnQuit?: boolean;
+}
+export declare function App({ operations, exitOnQuit, }: AppProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/cli/tui/components/Header.d.ts

@@ -0,0 +1,6 @@
+interface HeaderProps {
+    title: string;
+    subtitle?: string;
+}
+export declare function Header({ title, subtitle }: HeaderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/cli/tui/components/Menu.d.ts

@@ -0,0 +1,12 @@
+export interface MenuItem {
+    id: string;
+    label: string;
+    detail: string;
+    disabled?: boolean;
+}
+interface MenuProps {
+    items: MenuItem[];
+    selected: number;
+}
+export declare function Menu({ items, selected }: MenuProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/cli/tui/components/ModelChoiceScreen.d.ts

@@ -0,0 +1,9 @@
+import type { ModelOption } from '../model-catalog';
+interface ModelChoiceScreenProps {
+    currentModel: string;
+    draftModel: string;
+    options: readonly ModelOption[];
+    selected: number;
+}
+export declare function ModelChoiceScreen({ currentModel, draftModel, options, selected, }: ModelChoiceScreenProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/cli/tui/components/ModelScreen.d.ts

@@ -0,0 +1,14 @@
+import type { HarnessId } from '../../../harness/types';
+import type { ModelRoleInput } from '../../operations';
+export interface ModelRoleView extends ModelRoleInput {
+    currentModel: string;
+    dirty: boolean;
+}
+interface ModelScreenProps {
+    harness: HarnessId;
+    roles: ModelRoleView[];
+    selected: number;
+    actions: readonly string[];
+}
+export declare function ModelScreen({ harness, roles, selected, actions, }: ModelScreenProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/cli/tui/components/PathLine.d.ts

@@ -0,0 +1,8 @@
+export declare function wrapTerminalText(text: string, width?: number): string[];
+interface PathLineProps {
+    label?: string;
+    value: string;
+    width?: number;
+}
+export declare function PathLine({ label, value, width }: PathLineProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/cli/tui/components/PlanPreview.d.ts

@@ -0,0 +1,8 @@
+import type { OperationApplyResult, OperationPlan } from '../../operations';
+interface PlanPreviewProps {
+    plan: OperationPlan;
+    selectedAction: 'apply' | 'cancel';
+    result?: OperationApplyResult;
+}
+export declare function PlanPreview({ plan, selectedAction, result, }: PlanPreviewProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/cli/tui/components/StatusView.d.ts

@@ -0,0 +1,7 @@
+import type { HarnessStatusReport } from '../../operations';
+export type StatusSection = 'targets' | 'warnings' | 'disclaimers';
+interface StatusViewProps {
+    report: HarnessStatusReport;
+}
+export declare function StatusView({ report }: StatusViewProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/cli/tui/index.d.ts

@@ -0,0 +1,3 @@
+import { App } from './App';
+export declare function runInteractiveTui(): Promise<number>;
+export { App };