@norman-else/dsh-claude 0.1.0

package/lib/index.d.mts

@@ -0,0 +1,230 @@
+import z from "@deepseek-ai/schemastery";
+import { EffortLevel, Options, Query, SDKControlGetContextUsageResponse, SDKUserMessage, SlashCommand } from "@anthropic-ai/claude-agent-sdk";
+import { SubprocessRuntime } from "@deepseek-ai/dsh-subprocess";
+import { Context } from "@deepseek-ai/cordis";
+import { Agent } from "@deepseek-ai/dsh-agent";
+import { CommandDefinition, CommandDescriptor } from "@deepseek-ai/dsh-commands";
+import { SessionEvent } from "@deepseek-ai/dsh-session";
+import { ApprovalService } from "@deepseek-ai/dsh-user-approval";
+//#region src/command-bridge.d.ts
+/**
+ * Agent-scope command service contract. The commands service is unreachable
+ * from the host plugin's view of `agent.ctx` ("without inject"), but the
+ * preset route plugin runs INSIDE the agent's preset composition with
+ * `commands` injected. Registrations made through the provided service land
+ * in the agent's scope layer, which the command registry inherits into
+ * `list(agent)` for exactly that agent — invisible to every other session.
+ */
+interface ClaudeAgentCommandService {
+  list(agent: unknown): readonly Pick<CommandDescriptor, 'name'>[];
+  register(definition: CommandDefinition): () => void;
+}
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    claudeCommands?: ClaudeAgentCommandService;
+  }
+}
+//#endregion
+//#region src/events.d.ts
+type ClaudeActivityKind = 'status' | 'thinking' | 'tool-call' | 'tool-result' | 'permission' | 'subagent' | 'usage' | 'warning' | 'error';
+type ClaudeActivityPhase = 'started' | 'updated' | 'completed' | 'denied' | 'failed';
+interface ClaudeUsage {
+  inputTokens?: number;
+  outputTokens?: number;
+  cacheReadTokens?: number;
+  cacheCreationTokens?: number;
+  cumulativeCostUsd?: number;
+}
+interface ClaudeSessionBoundEvent {
+  claudeSessionId: string;
+  cliVersion?: string;
+  sdkVersion: string;
+  cwd: string;
+}
+interface ClaudeActivityEvent {
+  turn: number;
+  step: number;
+  ordinal: number;
+  kind: ClaudeActivityKind;
+  phase?: ClaudeActivityPhase;
+  /** Claude task-board identity for lifecycle activity; never a transcript path. */
+  taskId?: string;
+  toolUseId?: string;
+  /** Enclosing Claude tool call for subagent-nested activity. */
+  parentToolUseId?: string;
+  toolName?: string;
+  title?: string;
+  summary?: string;
+  detail?: string;
+  isError?: boolean;
+  usage?: ClaudeUsage;
+}
+interface ClaudeContextUsageCategory {
+  name: string;
+  tokens: number;
+  color: string;
+  isDeferred?: boolean;
+}
+interface ClaudeContextUsageEvent {
+  model: string;
+  totalTokens: number;
+  maxTokens: number;
+  percentage: number;
+  categories: readonly ClaudeContextUsageCategory[];
+}
+interface ClaudeContextUsageInput {
+  model: unknown;
+  totalTokens: unknown;
+  maxTokens: unknown;
+  percentage: unknown;
+  categories: readonly {
+    name?: unknown;
+    tokens?: unknown;
+    color?: unknown;
+    isDeferred?: unknown;
+  }[];
+}
+declare module '@deepseek-ai/dsh-session/types' {
+  interface SessionEventMap {
+    'claude-code/session-bound': ClaudeSessionBoundEvent;
+    'claude-code/activity': ClaudeActivityEvent;
+    'claude-code/context-usage': ClaudeContextUsageEvent;
+    'claude-code/tasks': ClaudeTasksEvent;
+  }
+}
+type ClaudeTaskStatus = 'running' | 'completed' | 'failed' | 'stopped' | 'killed';
+interface ClaudeTaskUsage {
+  totalTokens?: number;
+  toolUses?: number;
+  durationMs?: number;
+}
+interface ClaudeTaskInfo {
+  taskId: string;
+  description: string;
+  status: ClaudeTaskStatus;
+  /** DSH turn during which this task was first observed, when known. */
+  originTurn?: number;
+  subagentType?: string;
+  taskType?: string;
+  lastToolName?: string;
+  summary?: string;
+  usage?: ClaudeTaskUsage;
+  /** True while the task runs detached (background command/subagent). */
+  backgrounded?: boolean;
+}
+/** Level snapshot of one session's Claude task board, REPLACE semantics. */
+interface ClaudeTasksEvent {
+  tasks: readonly ClaudeTaskInfo[];
+}
+type ClaudeActivityInput = Omit<ClaudeActivityEvent, 'turn' | 'step' | 'ordinal' | 'summary' | 'detail'> & {
+  summary?: unknown;
+  detail?: unknown;
+};
+//#endregion
+//#region src/sidecar.d.ts
+declare const SIDECAR_SCHEMA_VERSION = 1;
+interface ClaudeSidecarProjection {
+  readonly schemaVersion: typeof SIDECAR_SCHEMA_VERSION;
+  readonly revision: number;
+  readonly binding?: ClaudeSessionBoundEvent;
+  readonly activities: readonly ClaudeActivityEvent[];
+  readonly contextUsage?: ClaudeContextUsageEvent;
+  readonly tasks?: ClaudeTasksEvent;
+}
+interface ClaudeSidecarRepositoryOptions {
+  readonly root?: string;
+  readonly legacyRoot?: string;
+}
+declare class ClaudeSidecarRepository {
+  #private;
+  readonly root: string;
+  readonly legacyRoot: string | undefined;
+  constructor(options?: ClaudeSidecarRepositoryOptions);
+  read(sessionId: string): Promise<ClaudeSidecarProjection>;
+  writeBinding(sessionId: string, value: Omit<ClaudeSessionBoundEvent, 'sdkVersion'> & {
+    sdkVersion?: string;
+  }): Promise<ClaudeSidecarProjection>;
+  appendActivity(sessionId: string, value: ClaudeActivityInput & {
+    turn: number;
+    step: number;
+    ordinal: number;
+  }): Promise<ClaudeSidecarProjection>;
+  writeContextUsage(sessionId: string, value: ClaudeContextUsageInput): Promise<ClaudeSidecarProjection>;
+  writeTasks(sessionId: string, value: readonly ClaudeTaskInfo[]): Promise<ClaudeSidecarProjection>;
+  importLegacy(sessionId: string, events: readonly SessionEvent[]): Promise<ClaudeSidecarProjection>;
+}
+//#endregion
+//#region src/supervisor.d.ts
+type ClaudeSupervisorState = 'starting' | 'idle' | 'running' | 'interrupting' | 'disconnected' | 'outcome-unknown' | 'disposed';
+interface ClaudeSupervisorConfig {
+  executablePath: string;
+  idleTimeoutMs: number;
+  maxProcesses: number;
+  defaultModel: string;
+}
+type ClaudeTurnStreamEvent = {
+  type: 'text-delta';
+  text: string;
+} | {
+  type: 'usage';
+  usage: ClaudeUsage;
+} | {
+  type: 'complete';
+  text: string;
+};
+type ClaudeThinkingMode = 'off' | 'ultracode' | EffortLevel;
+interface ClaudeTurnRequest {
+  agent: Agent;
+  prompt: string;
+  model?: string;
+  thinkingMode?: ClaudeThinkingMode;
+  signal?: AbortSignal;
+}
+interface ClaudeSupervisorSnapshot {
+  sessionId: string;
+  claudeSessionId?: string;
+  state: ClaudeSupervisorState;
+  cwd: string;
+  model: string;
+  thinkingMode?: ClaudeThinkingMode;
+  lastUsedAt: number;
+  pid?: number;
+}
+type ClaudeQueryFactory = (params: {
+  prompt: AsyncIterable<SDKUserMessage>;
+  options: Options;
+}) => Query;
+declare class ClaudeSupervisor {
+  #private;
+  constructor(dependencies: {
+    runtime: Pick<SubprocessRuntime, 'spawn'>;
+    approval: Pick<ApprovalService, 'request'>;
+    config: ClaudeSupervisorConfig;
+    queryFactory?: ClaudeQueryFactory;
+    runDetached?: <T>(operation: () => T) => T;
+    sidecar?: ClaudeSidecarRepository;
+  });
+  snapshots(): ClaudeSupervisorSnapshot[];
+  supportedCommands(agent: Agent, model?: string): Promise<readonly SlashCommand[]>;
+  contextUsage(agent: Agent, model?: string): Promise<SDKControlGetContextUsageResponse>;
+  contextWindow(model: string): number | undefined;
+  runTurn(request: ClaudeTurnRequest): Promise<AsyncIterable<ClaudeTurnStreamEvent>>;
+  disposeSession(sessionId: string): Promise<void>;
+  dispose(): Promise<void>;
+}
+//#endregion
+//#region src/index.d.ts
+declare const name = "llm-claude";
+declare const inject: string[];
+interface Config {
+  executablePath?: string;
+  model?: string;
+  idleTimeoutMs?: number;
+  maxProcesses?: number;
+}
+declare const Config: z<Config>;
+declare function mountClaudeMetadata(ctx: Context, supervisor: ClaudeSupervisor, agent: Agent, model: string, sidecar: ClaudeSidecarRepository, resolveCommands?: () => ClaudeAgentCommandService | undefined): (() => Promise<void>) | undefined;
+declare function apply(ctx: Context, config: Config): Promise<void>;
+//#endregion
+export { Config, apply, inject, mountClaudeMetadata, name };
+//# sourceMappingURL=index.d.mts.map