@canonmsg/claude-code-plugin 0.22.0 → 0.23.0

package/dist/session-defaults.d.ts

@@ -1,35 +0,0 @@
-import type { AgentDefinition, EffortLevel, ThinkingConfig } from '@anthropic-ai/claude-agent-sdk';
-export type ClaudeThinkingMode = 'adaptive' | 'off';
-export type ClaudeUltracodeMode = 'on' | 'off';
-export type ClaudeEffortLevel = Extract<EffortLevel, 'low' | 'medium' | 'high' | 'xhigh' | 'max'>;
-export interface ClaudeSessionDefaults {
-    model?: string;
-    effort?: ClaudeEffortLevel;
-    thinking?: ClaudeThinkingMode;
-    ultracode?: ClaudeUltracodeMode;
-    fallbackModel?: string;
-    agentProgressSummaries?: boolean;
-    agents?: Record<string, AgentDefinition>;
-}
-export interface ClaudeSessionControlValues {
-    thinking?: ClaudeThinkingMode;
-    ultracode?: ClaudeUltracodeMode;
-}
-export interface ClaudeEffectiveSessionSettings extends ClaudeSessionDefaults {
-    runtimeControlValues: Record<string, string>;
-}
-export declare const CLAUDE_EFFORT_LEVELS: readonly ClaudeEffortLevel[];
-export declare function parseClaudeThinkingMode(value: unknown): ClaudeThinkingMode | undefined;
-export declare function parseClaudeUltracodeMode(value: unknown): ClaudeUltracodeMode | undefined;
-export declare function parseClaudeSessionDefaults(raw: unknown): ClaudeSessionDefaults;
-export declare function parseClaudeSessionControlValues(values: Record<string, string> | null | undefined): ClaudeSessionControlValues;
-export declare function claudeThinkingToConfig(mode: ClaudeThinkingMode | undefined): ThinkingConfig | undefined;
-export declare function claudeThinkingToFlagValue(mode: ClaudeThinkingMode): boolean;
-export declare function resolveEffectiveSessionSettings(input: {
-    profileDefaults?: ClaudeSessionDefaults;
-    sessionConfig?: {
-        model?: string;
-        effort?: ClaudeEffortLevel;
-        runtimeControlValues?: Record<string, string>;
-    } | null;
-}): ClaudeEffectiveSessionSettings;

package/dist/session-defaults.js

@@ -1,124 +0,0 @@
-export const CLAUDE_EFFORT_LEVELS = ['low', 'medium', 'high', 'xhigh', 'max'];
-const CLAUDE_EFFORT_VALUES = new Set(CLAUDE_EFFORT_LEVELS);
-function optionalString(value) {
-    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
-}
-function optionalBoolean(value) {
-    return typeof value === 'boolean' ? value : undefined;
-}
-export function parseClaudeThinkingMode(value) {
-    if (value === false || value === 'off' || value === 'disabled')
-        return 'off';
-    if (value === true || value === 'on' || value === 'adaptive' || value === 'enabled')
-        return 'adaptive';
-    return undefined;
-}
-export function parseClaudeUltracodeMode(value) {
-    if (value === true || value === 'on' || value === 'enabled')
-        return 'on';
-    if (value === false || value === 'off' || value === 'disabled')
-        return 'off';
-    return undefined;
-}
-function parseEffort(value) {
-    const normalized = optionalString(value);
-    if (!normalized)
-        return undefined;
-    return CLAUDE_EFFORT_VALUES.has(normalized)
-        ? normalized
-        : undefined;
-}
-function parseStringArray(value) {
-    if (!Array.isArray(value))
-        return undefined;
-    const out = value
-        .map((entry) => optionalString(entry))
-        .filter((entry) => Boolean(entry));
-    return out.length > 0 ? out : undefined;
-}
-function parseAgentDefinition(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return null;
-    const data = value;
-    const description = optionalString(data.description);
-    const prompt = optionalString(data.prompt);
-    if (!description || !prompt)
-        return null;
-    return {
-        description,
-        prompt,
-        ...(parseStringArray(data.tools) ? { tools: parseStringArray(data.tools) } : {}),
-        ...(parseStringArray(data.disallowedTools) ? { disallowedTools: parseStringArray(data.disallowedTools) } : {}),
-        ...(optionalString(data.model) ? { model: optionalString(data.model) } : {}),
-        ...(parseStringArray(data.skills) ? { skills: parseStringArray(data.skills) } : {}),
-        ...(typeof data.maxTurns === 'number' && Number.isFinite(data.maxTurns) && data.maxTurns > 0
-            ? { maxTurns: Math.floor(data.maxTurns) }
-            : {}),
-        ...(typeof data.background === 'boolean' ? { background: data.background } : {}),
-        ...(parseEffort(data.effort) ? { effort: parseEffort(data.effort) } : {}),
-    };
-}
-function parseAgents(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return undefined;
-    const out = {};
-    for (const [rawName, rawAgent] of Object.entries(value)) {
-        const name = rawName.trim();
-        if (!name)
-            continue;
-        const agent = parseAgentDefinition(rawAgent);
-        if (agent)
-            out[name] = agent;
-    }
-    return Object.keys(out).length > 0 ? out : undefined;
-}
-export function parseClaudeSessionDefaults(raw) {
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
-        return {};
-    const data = raw;
-    return {
-        ...(optionalString(data.model) ? { model: optionalString(data.model) } : {}),
-        ...(parseEffort(data.effort) ? { effort: parseEffort(data.effort) } : {}),
-        ...(parseClaudeThinkingMode(data.thinking) ? { thinking: parseClaudeThinkingMode(data.thinking) } : {}),
-        ...(parseClaudeUltracodeMode(data.ultracode) ? { ultracode: parseClaudeUltracodeMode(data.ultracode) } : {}),
-        ...(optionalString(data.fallbackModel) ? { fallbackModel: optionalString(data.fallbackModel) } : {}),
-        ...(optionalBoolean(data.agentProgressSummaries) !== undefined
-            ? { agentProgressSummaries: optionalBoolean(data.agentProgressSummaries) }
-            : {}),
-        ...(parseAgents(data.agents) ? { agents: parseAgents(data.agents) } : {}),
-    };
-}
-export function parseClaudeSessionControlValues(values) {
-    return {
-        ...(parseClaudeThinkingMode(values?.thinking) ? { thinking: parseClaudeThinkingMode(values?.thinking) } : {}),
-        ...(parseClaudeUltracodeMode(values?.ultracode) ? { ultracode: parseClaudeUltracodeMode(values?.ultracode) } : {}),
-    };
-}
-export function claudeThinkingToConfig(mode) {
-    if (mode === 'adaptive')
-        return { type: 'adaptive' };
-    if (mode === 'off')
-        return { type: 'disabled' };
-    return undefined;
-}
-export function claudeThinkingToFlagValue(mode) {
-    return mode !== 'off';
-}
-export function resolveEffectiveSessionSettings(input) {
-    const controlValues = parseClaudeSessionControlValues(input.sessionConfig?.runtimeControlValues);
-    const runtimeControlValues = {
-        ...(input.profileDefaults?.thinking ? { thinking: input.profileDefaults.thinking } : {}),
-        ...(input.profileDefaults?.ultracode ? { ultracode: input.profileDefaults.ultracode } : {}),
-        ...(input.sessionConfig?.runtimeControlValues ?? {}),
-        ...(controlValues.thinking ? { thinking: controlValues.thinking } : {}),
-        ...(controlValues.ultracode ? { ultracode: controlValues.ultracode } : {}),
-    };
-    return {
-        ...(input.profileDefaults ?? {}),
-        ...(input.sessionConfig?.model ? { model: input.sessionConfig.model } : {}),
-        ...(input.sessionConfig?.effort ? { effort: input.sessionConfig.effort } : {}),
-        ...(controlValues.thinking ? { thinking: controlValues.thinking } : {}),
-        ...(controlValues.ultracode ? { ultracode: controlValues.ultracode } : {}),
-        runtimeControlValues,
-    };
-}

package/dist/subagent-activity.d.ts

@@ -1,11 +0,0 @@
-import type { SDKTaskNotificationMessage, SDKTaskProgressMessage, SDKTaskStartedMessage, SDKTaskUpdatedMessage } from '@anthropic-ai/claude-agent-sdk';
-type ClaudeTaskMessage = SDKTaskNotificationMessage | SDKTaskProgressMessage | SDKTaskStartedMessage | SDKTaskUpdatedMessage;
-export interface ClaudeSubagentActivityBlock {
-    id: string;
-    kind: 'status';
-    status: 'running' | 'completed' | 'failed';
-    title: string;
-    text?: string;
-}
-export declare function mapClaudeSubagentActivity(message: ClaudeTaskMessage): ClaudeSubagentActivityBlock | null;
-export {};

package/dist/subagent-activity.js

@@ -1,51 +0,0 @@
-function titleForMessage(message) {
-    const subtype = message.subtype;
-    if (subtype === 'task_started') {
-        return message.subagent_type
-            ? `Subagent started: ${message.subagent_type}`
-            : 'Subagent started';
-    }
-    if (subtype === 'task_progress') {
-        return message.subagent_type
-            ? `Subagent progress: ${message.subagent_type}`
-            : 'Subagent progress';
-    }
-    if (subtype === 'task_updated')
-        return 'Subagent updated';
-    return `Subagent ${message.status}`;
-}
-function textForMessage(message) {
-    if (message.subtype === 'task_started')
-        return message.description;
-    if (message.subtype === 'task_progress')
-        return message.summary ?? message.description;
-    if (message.subtype === 'task_updated')
-        return message.patch.description ?? message.patch.error;
-    return message.summary;
-}
-function statusForMessage(message) {
-    if (message.subtype === 'task_notification') {
-        if (message.status === 'completed')
-            return 'completed';
-        return 'failed';
-    }
-    if (message.subtype === 'task_updated') {
-        if (message.patch.status === 'completed')
-            return 'completed';
-        if (message.patch.status === 'failed' || message.patch.status === 'killed')
-            return 'failed';
-    }
-    return 'running';
-}
-export function mapClaudeSubagentActivity(message) {
-    if ('skip_transcript' in message && message.skip_transcript)
-        return null;
-    const text = textForMessage(message);
-    return {
-        id: `task:${message.task_id}`,
-        kind: 'status',
-        status: statusForMessage(message),
-        title: titleForMessage(message),
-        ...(text ? { text } : {}),
-    };
-}