@clinebot/shared 0.0.8

package/dist/llms/model-id.d.ts

@@ -0,0 +1,7 @@
+export declare const MODELS_DEV_PROVIDER_KEY_ENTRIES: ReadonlyArray<{
+    modelsDevKey: string;
+    generatedProviderId?: string;
+    runtimeProviderId?: string;
+}>;
+export declare const MODELS_DEV_PROVIDER_KEY_MAP: Record<string, string>;
+export declare function resolveProviderModelCatalogKeys(providerId: string): string[];

package/dist/llms/tools.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Types and Zod Schemas for the Agent Package
+ *
+ * This module defines all TypeScript types and Zod validation schemas
+ * for agent configuration, tools, events, and results.
+ */
+import { z } from "zod";
+/**
+ * Context passed to tool execution functions
+ */
+export interface ToolContext {
+    /** Unique identifier for the agent instance */
+    agentId: string;
+    /** Unique identifier for the current conversation */
+    conversationId: string;
+    /** Current iteration number in the agentic loop */
+    iteration: number;
+    /** Abort signal for cancellation */
+    abortSignal?: AbortSignal;
+    /** Optional metadata for the tool execution */
+    metadata?: Record<string, unknown>;
+}
+export interface ToolPolicy {
+    /**
+     * Whether the tool can be executed at all.
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Whether this tool can run without asking the client for approval.
+     * @default true
+     */
+    autoApprove?: boolean;
+}
+export declare const ToolContextSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    conversationId: z.ZodString;
+    iteration: z.ZodNumber;
+    abortSignal: z.ZodOptional<z.ZodCustom<AbortSignal, AbortSignal>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * A tool that the agent can use
+ *
+ * @template TInput - The type of the input to the tool
+ * @template TOutput - The type of the output from the tool
+ */
+export interface Tool<TInput = unknown, TOutput = unknown> {
+    /** Unique name for the tool */
+    name: string;
+    /** Human-readable description of what the tool does */
+    description: string;
+    /** JSON Schema defining the tool's input parameters */
+    inputSchema: Record<string, unknown>;
+    /** The function that executes the tool */
+    execute: (input: TInput, context: ToolContext) => Promise<TOutput>;
+    /**
+     * Optional timeout in milliseconds for tool execution
+     * @default 30000 (30 seconds)
+     */
+    timeoutMs?: number;
+    /**
+     * Whether the tool can be retried on failure
+     * @default true
+     */
+    retryable?: boolean;
+    /**
+     * Maximum number of retries for this tool
+     * @default 2
+     */
+    maxRetries?: number;
+}
+/**
+ * Record of a tool call execution
+ */
+export interface ToolCallRecord {
+    /** Unique identifier for this tool call */
+    id: string;
+    /** Name of the tool that was called */
+    name: string;
+    /** Input passed to the tool */
+    input: unknown;
+    /** Output returned from the tool (if successful) */
+    output: unknown;
+    /** Error message (if the tool failed) */
+    error?: string;
+    /** Time taken to execute the tool in milliseconds */
+    durationMs: number;
+    /** Timestamp when the tool call started */
+    startedAt: Date;
+    /** Timestamp when the tool call ended */
+    endedAt: Date;
+}
+export interface ToolApprovalRequest {
+    agentId: string;
+    conversationId: string;
+    iteration: number;
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    policy: ToolPolicy;
+}
+export interface ToolApprovalResult {
+    approved: boolean;
+    reason?: string;
+}
+export declare const ToolCallRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    input: z.ZodUnknown;
+    output: z.ZodUnknown;
+    error: z.ZodOptional<z.ZodString>;
+    durationMs: z.ZodNumber;
+    startedAt: z.ZodDate;
+    endedAt: z.ZodDate;
+}, z.core.$strip>;

package/dist/logging/logger.d.ts

@@ -0,0 +1,8 @@
+export interface BasicLogger {
+    debug?: (message: string, metadata?: Record<string, unknown>) => void;
+    info?: (message: string, metadata?: Record<string, unknown>) => void;
+    warn?: (message: string, metadata?: Record<string, unknown>) => void;
+    error?: (message: string, metadata?: Record<string, unknown> & {
+        error?: unknown;
+    }) => void;
+}

package/dist/parse/json.d.ts

@@ -0,0 +1,2 @@
+export declare function parseJsonStream(input: unknown): unknown;
+export declare function safeJsonStringify(input: unknown): string;

package/dist/parse/time.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Parses a date string and returns a human-readable format.
+ * If the input is invalid, it returns the original string or a placeholder.
+ *
+ * @param dateStr - The date string to parse.
+ * @returns A human-readable date string or the original input if invalid.
+ */
+export declare function formatHumanReadableDate(dateStr?: string): string;

package/dist/parse/zod.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Zod Utilities
+ *
+ * Helper functions for working with Zod schemas.
+ */
+import { z } from "zod";
+/**
+ * Validate input using a Zod schema
+ * Throws a formatted error if validation fails
+ */
+export declare function validateWithZod<T>(schema: z.ZodType<T>, input: unknown): T;
+export declare function zodToJsonSchema(schema: z.ZodTypeAny): Record<string, unknown>;

package/dist/prompt/format.d.ts

@@ -0,0 +1,4 @@
+export declare function formatFileContentBlock(path: string, content: string): string;
+export declare function formatUserInputBlock(input: string, mode?: "act" | "plan"): string;
+export declare function normalizeUserInput(input?: string): string;
+export declare function xmlTagsRemoval(input?: string, tag?: string): string;

package/dist/rpc/runtime.d.ts

@@ -0,0 +1,258 @@
+import type { AgentMode, SessionExecutionConfig, SessionPromptConfig } from "../session/runtime-config";
+export type RpcAgentMode = AgentMode;
+export interface RpcSessionStorageOptions {
+    homeDir?: string;
+}
+export interface RpcChatRuntimeConfigBase extends SessionPromptConfig {
+    cwd?: string;
+    apiKey: string;
+    logger?: RpcChatRuntimeLoggerConfig;
+    enableTools: boolean;
+    enableSpawn: boolean;
+    enableTeams: boolean;
+    autoApproveTools?: boolean;
+    teamName: string;
+    missionStepInterval: number;
+    missionTimeIntervalMs: number;
+    toolPolicies?: SessionExecutionConfig["toolPolicies"];
+}
+export interface RpcChatRuntimeLoggerConfig {
+    enabled?: boolean;
+    level?: "trace" | "debug" | "info" | "warn" | "error" | "fatal" | "silent";
+    destination?: string;
+    name?: string;
+    bindings?: Record<string, string | number | boolean>;
+}
+export interface RpcChatStartSessionRequest extends RpcChatRuntimeConfigBase {
+    sessionId?: string;
+    workspaceRoot: string;
+    provider: string;
+    model: string;
+    sessions?: RpcSessionStorageOptions;
+    initialMessages?: RpcChatMessage[];
+}
+export interface RpcChatStartSessionArtifacts {
+    sessionId: string;
+    manifestPath: string;
+    transcriptPath: string;
+    hookPath: string;
+    messagesPath: string;
+}
+export interface RpcChatStartSessionResponse {
+    sessionId: string;
+    startResult?: RpcChatStartSessionArtifacts;
+}
+export interface RpcChatAttachmentFile {
+    name: string;
+    content: string;
+}
+export interface RpcChatAttachments {
+    userImages?: string[];
+    userFiles?: RpcChatAttachmentFile[];
+}
+export interface RpcChatMessage {
+    role?: string;
+    content?: unknown;
+    [key: string]: unknown;
+}
+export interface RpcChatRunTurnRequest {
+    config: RpcChatStartSessionRequest;
+    messages?: RpcChatMessage[];
+    prompt: string;
+    attachments?: RpcChatAttachments;
+}
+export interface RpcChatToolCallResult {
+    name: string;
+    input?: unknown;
+    output?: unknown;
+    error?: string;
+    durationMs?: number;
+}
+export interface RpcChatTurnResult {
+    text: string;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadTokens?: number;
+        cacheWriteTokens?: number;
+        totalCost?: number;
+    };
+    inputTokens: number;
+    outputTokens: number;
+    iterations: number;
+    finishReason: string;
+    messages: RpcChatMessage[];
+    toolCalls: RpcChatToolCallResult[];
+}
+export interface RpcProviderModel {
+    id: string;
+    name: string;
+    supportsAttachments?: boolean;
+    supportsVision?: boolean;
+    supportsReasoning?: boolean;
+}
+export interface RpcProviderListItem {
+    id: string;
+    name: string;
+    models: number | null;
+    color: string;
+    letter: string;
+    enabled: boolean;
+    apiKey?: string;
+    oauthAccessTokenPresent?: boolean;
+    baseUrl?: string;
+    defaultModelId?: string;
+    authDescription: string;
+    baseUrlDescription: string;
+    modelList?: RpcProviderModel[];
+}
+export interface RpcProviderCatalogResponse {
+    providers: RpcProviderListItem[];
+    settingsPath: string;
+}
+export interface RpcProviderModelsResponse {
+    providerId: string;
+    models: RpcProviderModel[];
+}
+export interface RpcClineAccountOrganization {
+    active: boolean;
+    memberId: string;
+    name: string;
+    organizationId: string;
+    roles: Array<"admin" | "member" | "owner">;
+}
+export interface RpcClineAccountUser {
+    id: string;
+    email: string;
+    displayName: string;
+    photoUrl: string;
+    createdAt: string;
+    updatedAt: string;
+    organizations: RpcClineAccountOrganization[];
+}
+export interface RpcClineAccountBalance {
+    balance: number;
+    userId: string;
+}
+export interface RpcClineAccountUsageTransaction {
+    aiInferenceProviderName: string;
+    aiModelName: string;
+    aiModelTypeName: string;
+    completionTokens: number;
+    costUsd: number;
+    createdAt: string;
+    creditsUsed: number;
+    generationId: string;
+    id: string;
+    metadata: {
+        additionalProp1: string;
+        additionalProp2: string;
+        additionalProp3: string;
+    };
+    operation?: string;
+    organizationId: string;
+    promptTokens: number;
+    totalTokens: number;
+    userId: string;
+}
+export interface RpcClineAccountPaymentTransaction {
+    paidAt: string;
+    creatorId: string;
+    amountCents: number;
+    credits: number;
+}
+export interface RpcClineAccountOrganizationBalance {
+    balance: number;
+    organizationId: string;
+}
+export interface RpcClineAccountOrganizationUsageTransaction {
+    aiInferenceProviderName: string;
+    aiModelName: string;
+    aiModelTypeName: string;
+    completionTokens: number;
+    costUsd: number;
+    createdAt: string;
+    creditsUsed: number;
+    generationId: string;
+    id: string;
+    memberDisplayName: string;
+    memberEmail: string;
+    metadata: {
+        additionalProp1: string;
+        additionalProp2: string;
+        additionalProp3: string;
+    };
+    operation?: string;
+    organizationId: string;
+    promptTokens: number;
+    totalTokens: number;
+    userId: string;
+}
+import type { OAuthProviderId } from "../auth/constants";
+export type RpcOAuthProviderId = OAuthProviderId;
+export type RpcProviderCapability = "reasoning" | "prompt-cache" | "streaming" | "tools" | "vision";
+export interface RpcListProvidersActionRequest {
+    action: "listProviders";
+}
+export interface RpcGetProviderModelsActionRequest {
+    action: "getProviderModels";
+    providerId: string;
+}
+export interface RpcSaveProviderSettingsActionRequest {
+    action: "saveProviderSettings";
+    providerId: string;
+    enabled?: boolean;
+    apiKey?: string;
+    baseUrl?: string;
+}
+export interface RpcAddProviderActionRequest {
+    action: "addProvider";
+    providerId: string;
+    name: string;
+    baseUrl: string;
+    apiKey?: string;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+    models?: string[];
+    defaultModelId?: string;
+    modelsSourceUrl?: string;
+    capabilities?: RpcProviderCapability[];
+}
+export type RpcProviderSettingsActionRequest = RpcListProvidersActionRequest | RpcGetProviderModelsActionRequest | RpcSaveProviderSettingsActionRequest | RpcAddProviderActionRequest;
+export type RpcClineAccountActionRequest = {
+    action: "clineAccount";
+    operation: "fetchMe";
+} | {
+    action: "clineAccount";
+    operation: "fetchBalance";
+    userId?: string;
+} | {
+    action: "clineAccount";
+    operation: "fetchUsageTransactions";
+    userId?: string;
+} | {
+    action: "clineAccount";
+    operation: "fetchPaymentTransactions";
+    userId?: string;
+} | {
+    action: "clineAccount";
+    operation: "fetchUserOrganizations";
+} | {
+    action: "clineAccount";
+    operation: "fetchOrganizationBalance";
+    organizationId: string;
+} | {
+    action: "clineAccount";
+    operation: "fetchOrganizationUsageTransactions";
+    organizationId: string;
+    memberId?: string;
+} | {
+    action: "clineAccount";
+    operation: "switchAccount";
+    organizationId?: string | null;
+};
+export type RpcProviderActionRequest = RpcProviderSettingsActionRequest | RpcClineAccountActionRequest;
+export interface RpcProviderOAuthLoginResponse {
+    provider: RpcOAuthProviderId;
+    accessToken: string;
+}

package/dist/rpc/team-progress.d.ts

@@ -0,0 +1,53 @@
+export declare const RPC_TEAM_PROGRESS_EVENT_TYPE = "runtime.team.progress.v1";
+export declare const RPC_TEAM_LIFECYCLE_EVENT_TYPE = "runtime.team.lifecycle.v1";
+export type TeamProgressMemberRole = "lead" | "teammate";
+export type TeamProgressMemberStatus = "idle" | "running" | "stopped";
+export type TeamProgressTaskStatus = "pending" | "in_progress" | "blocked" | "completed";
+export type TeamProgressRunStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "interrupted";
+export type TeamProgressOutcomeStatus = "draft" | "in_review" | "finalized";
+export type TeamProgressOutcomeFragmentStatus = "draft" | "reviewed" | "rejected";
+export interface TeamProgressCounts<TStatus extends string> {
+    total: number;
+    byStatus: Record<TStatus, number>;
+}
+export interface TeamProgressSummary {
+    teamName: string;
+    updatedAt: string;
+    members: TeamProgressCounts<TeamProgressMemberStatus> & {
+        leadCount: number;
+        teammateCount: number;
+    };
+    tasks: TeamProgressCounts<TeamProgressTaskStatus> & {
+        blockedTaskIds: string[];
+        readyTaskIds: string[];
+        completionPct: number;
+    };
+    runs: TeamProgressCounts<TeamProgressRunStatus> & {
+        activeRunIds: string[];
+        latestRunId?: string;
+    };
+    outcomes: TeamProgressCounts<TeamProgressOutcomeStatus> & {
+        finalizedPct: number;
+        missingRequiredSections: string[];
+    };
+    fragments: TeamProgressCounts<TeamProgressOutcomeFragmentStatus>;
+}
+export interface TeamProgressLifecycleEvent {
+    teamName: string;
+    sessionId: string;
+    eventType: string;
+    ts: string;
+    agentId?: string;
+    taskId?: string;
+    runId?: string;
+    outcomeId?: string;
+    fragmentId?: string;
+    message?: string;
+}
+export interface TeamProgressProjectionEvent {
+    type: "team_progress_projection";
+    version: 1;
+    sessionId: string;
+    summary: TeamProgressSummary;
+    lastEvent: TeamProgressLifecycleEvent;
+}

package/dist/services/telemetry-config.d.ts

@@ -0,0 +1,6 @@
+import type { OpenTelemetryClientConfig, TelemetryMetadata } from "./telemetry";
+export interface ClineTelemetryServiceConfig extends OpenTelemetryClientConfig {
+    metadata: TelemetryMetadata;
+}
+export declare function createClineTelemetryServiceMetadata(overrides?: Partial<TelemetryMetadata>): TelemetryMetadata;
+export declare function createClineTelemetryServiceConfig(configOverrides?: Partial<ClineTelemetryServiceConfig>): ClineTelemetryServiceConfig;

package/dist/services/telemetry.d.ts

@@ -0,0 +1,102 @@
+export type TelemetryPrimitive = string | number | boolean | null | undefined;
+export type TelemetryValue = TelemetryPrimitive | TelemetryObject | TelemetryArray;
+export type TelemetryObject = {
+    [key: string]: TelemetryValue;
+};
+export type TelemetryArray = Array<TelemetryValue>;
+export type TelemetryProperties = TelemetryObject;
+export interface TelemetryMetadata {
+    extension_version: string;
+    cline_type: string;
+    platform: string;
+    platform_version: string;
+    os_type: string;
+    os_version: string;
+    is_dev?: string;
+}
+export interface ITelemetryService {
+    setDistinctId(distinctId?: string): void;
+    setMetadata(metadata: Partial<TelemetryMetadata>): void;
+    updateMetadata(metadata: Partial<TelemetryMetadata>): void;
+    setCommonProperties(properties: TelemetryProperties): void;
+    updateCommonProperties(properties: TelemetryProperties): void;
+    isEnabled(): boolean;
+    capture(input: {
+        event: string;
+        properties?: TelemetryProperties;
+    }): void;
+    captureRequired(event: string, properties?: TelemetryProperties): void;
+    recordCounter(name: string, value: number, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    recordHistogram(name: string, value: number, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    recordGauge(name: string, value: number | null, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    flush(): Promise<void>;
+    dispose(): Promise<void>;
+}
+export interface OpenTelemetryClientConfig {
+    /**
+     * Whether telemetry is enabled via OTEL_TELEMETRY_ENABLED
+     */
+    enabled: boolean;
+    /**
+     * Metrics exporter type(s) - can be comma-separated for multiple exporters
+     * Examples: "console", "otlp", "prometheus", "console,otlp"
+     */
+    metricsExporter?: string;
+    /**
+     * Logs/events exporter type(s) - can be comma-separated for multiple exporters
+     * Examples: "console", "otlp"
+     */
+    logsExporter?: string;
+    /**
+     * Protocol for OTLP exporters. SDK support is currently limited to "http/json".
+     */
+    otlpProtocol?: string;
+    /**
+     * General OTLP endpoint (used if specific endpoints not set)
+     */
+    otlpEndpoint?: string;
+    /**
+     * General OTLP headers
+     */
+    otlpHeaders?: Record<string, string>;
+    /**
+     * Metrics-specific OTLP protocol
+     */
+    otlpMetricsProtocol?: string;
+    /**
+     * Metrics-specific OTLP endpoint
+     */
+    otlpMetricsEndpoint?: string;
+    otlpMetricsHeaders?: Record<string, string>;
+    /**
+     * Logs-specific OTLP protocol
+     */
+    otlpLogsProtocol?: string;
+    /**
+     * Logs-specific OTLP endpoint
+     */
+    otlpLogsEndpoint?: string;
+    otlpLogsHeaders?: Record<string, string>;
+    /**
+     * Metric export interval in milliseconds (for console exporter)
+     */
+    metricExportInterval?: number;
+    /**
+     * Whether to use insecure (non-TLS) connections for gRPC OTLP exporters
+     * Set to "true" for local development without TLS
+     * Default: false (uses TLS)
+     */
+    otlpInsecure?: boolean;
+    /**
+     * Maximum batch size for log records (default: 512)
+     */
+    logBatchSize?: number;
+    /**
+     * Maximum time to wait before exporting logs in milliseconds (default: 5000)
+     */
+    logBatchTimeout?: number;
+    /**
+     * Maximum queue size for log records (default: 2048)
+     */
+    logMaxQueueSize?: number;
+}

package/dist/session/hook-context.d.ts

@@ -0,0 +1,14 @@
+export interface HookSessionContext {
+    rootSessionId?: string;
+    hookLogPath?: string;
+}
+export interface HookSessionContextLookup {
+    hookName?: string;
+    conversationId?: string;
+    agentId?: string;
+    parentAgentId?: string | null;
+}
+export type HookSessionContextProvider = HookSessionContext | ((input?: HookSessionContextLookup) => HookSessionContext | undefined);
+export declare function resolveHookSessionContext(provider?: HookSessionContextProvider, input?: HookSessionContextLookup): HookSessionContext | undefined;
+export declare function resolveRootSessionId(context: HookSessionContext | undefined): string | undefined;
+export declare function resolveHookLogPath(context: HookSessionContext | undefined): string | undefined;

package/dist/session/records.d.ts

@@ -0,0 +1,32 @@
+export declare const SESSION_STATUS_VALUES: readonly ["running", "completed", "failed", "cancelled"];
+export type SharedSessionStatus = (typeof SESSION_STATUS_VALUES)[number];
+export interface SessionLineage {
+    parentSessionId?: string;
+    agentId?: string;
+    parentAgentId?: string;
+    conversationId?: string;
+    isSubagent: boolean;
+}
+export interface SessionRuntimeRecordShape extends SessionLineage {
+    source: string;
+    pid?: number;
+    startedAt: string;
+    endedAt?: string | null;
+    exitCode?: number | null;
+    status: SharedSessionStatus;
+    interactive: boolean;
+    provider: string;
+    model: string;
+    cwd: string;
+    workspaceRoot: string;
+    teamName?: string;
+    enableTools: boolean;
+    enableSpawn: boolean;
+    enableTeams: boolean;
+    prompt?: string;
+    metadata?: Record<string, unknown>;
+    transcriptPath?: string;
+    hookPath?: string;
+    messagesPath?: string;
+    updatedAt: string;
+}

package/dist/session/runtime-config.d.ts

@@ -0,0 +1,20 @@
+import type { ToolPolicy } from "../llms/tools";
+export type AgentMode = "act" | "plan";
+export interface SessionPromptConfig {
+    mode?: AgentMode;
+    systemPrompt?: string;
+    rules?: string;
+    maxIterations?: number;
+}
+export interface SessionWorkspaceConfig {
+    cwd: string;
+    workspaceRoot?: string;
+}
+export interface SessionExecutionConfig {
+    enableTools: boolean;
+    teamName?: string;
+    missionLogIntervalSteps?: number;
+    missionLogIntervalMs?: number;
+    maxConsecutiveMistakes?: number;
+    toolPolicies?: Record<string, ToolPolicy>;
+}

package/dist/session/runtime-env.d.ts

@@ -0,0 +1,8 @@
+export interface RuntimeEnv {
+    name: string;
+    version: string;
+    platform: string;
+    platform_version: string;
+    os_type: string;
+    os_version: string;
+}

package/dist/storage/index.d.ts

@@ -0,0 +1 @@
+export { AGENT_CONFIG_DIRECTORY_NAME, CLINE_MCP_SETTINGS_FILE_NAME, ensureHookLogDir, ensureParentDir, HOOKS_CONFIG_DIRECTORY_NAME, RULES_CONFIG_DIRECTORY_NAME, resolveAgentConfigSearchPaths, resolveAgentsConfigDirPath, resolveClineDataDir, resolveDocumentsAgentConfigDirectoryPath, resolveDocumentsClineDirectoryPath, resolveDocumentsHooksDirectoryPath, resolveDocumentsRulesDirectoryPath, resolveDocumentsWorkflowsDirectoryPath, resolveHooksConfigSearchPaths, resolveMcpSettingsPath, resolvePluginConfigSearchPaths, resolveProviderSettingsPath, resolveRulesConfigSearchPaths, resolveSessionDataDir, resolveSkillsConfigSearchPaths, resolveTeamDataDir, resolveWorkflowsConfigSearchPaths, SKILLS_CONFIG_DIRECTORY_NAME, setHomeDir, setHomeDirIfUnset, WORKFLOWS_CONFIG_DIRECTORY_NAME, } from "./paths";

package/dist/storage/index.js

@@ -0,0 +1 @@
+var L=Object.defineProperty;var U=(o)=>o;function W(o,n){this[o]=U.bind(null,n)}var x=(o,n)=>{for(var S in n)L(o,S,{get:n[S],enumerable:!0,configurable:!0,set:W.bind(n,S)})};import{existsSync as _,mkdirSync as O}from"node:fs";import{dirname as R,join as v}from"node:path";var l="agents",E="hooks",g="skills",G="rules",I="workflows",A="plugins",y="cline_mcp_settings.json",D=process?.env?.HOME||"~",F=!1;function Y(o){let n=o.trim();if(!n)return;D=n,F=!0}function b(o){if(F)return;let n=o.trim();if(!n)return;D=n}function N(){return v(D,"Documents","Cline")}function H(){return v(N(),"Agents")}function M(){return v(N(),"Hooks")}function T(){return v(N(),"Rules")}function e(){return v(N(),"Workflows")}function C(){let o=process.env.CLINE_DATA_DIR?.trim();if(o)return o;return v(D,".cline","data")}function j(){let o=process.env.CLINE_SESSION_DATA_DIR?.trim();if(o)return o;return v(C(),"sessions")}function m(){let o=process.env.CLINE_TEAM_DATA_DIR?.trim();if(o)return o;return v(C(),"teams")}function q(){let o=process.env.CLINE_PROVIDER_SETTINGS_PATH?.trim();if(o)return o;return v(C(),"settings","providers.json")}function z(){let o=process.env.CLINE_MCP_SETTINGS_PATH?.trim();if(o)return o;return v(C(),"settings",y)}function s(o){let n=new Set,S=[];for(let u of o){if(!u||n.has(u))continue;n.add(u),S.push(u)}return S}function B(o){if(!o)return[];return[v(o,".clinerules",g),v(o,".cline",g),v(o,".claude",g),v(o,".agents",g)]}function f(){return v(C(),"settings",l)}function J(){return[H(),f()]}function Q(o){return s([o?v(o,".clinerules",E):"",M()])}function V(o){return s([...B(o),v(C(),"settings",g),v(D,".cline",g),v(D,".agents",g)])}function Z(o){return s([o?v(o,".clinerules"):"",v(C(),"settings",G),T()])}function $(o){return s([o?v(o,".clinerules","workflows"):"",v(C(),"settings",I),e()])}function X(o){return s([o?v(o,".clinerules",A):"",v(D,".cline",A),v(D,".agents",A)])}function K(o){let n=R(o);if(!_(n))O(n,{recursive:!0})}function r(o){if(o?.trim())return K(o),R(o);let n=v(C(),"hooks");if(!_(n))O(n,{recursive:!0});return n}export{b as setHomeDirIfUnset,Y as setHomeDir,$ as resolveWorkflowsConfigSearchPaths,m as resolveTeamDataDir,V as resolveSkillsConfigSearchPaths,j as resolveSessionDataDir,Z as resolveRulesConfigSearchPaths,q as resolveProviderSettingsPath,X as resolvePluginConfigSearchPaths,z as resolveMcpSettingsPath,Q as resolveHooksConfigSearchPaths,e as resolveDocumentsWorkflowsDirectoryPath,T as resolveDocumentsRulesDirectoryPath,M as resolveDocumentsHooksDirectoryPath,N as resolveDocumentsClineDirectoryPath,H as resolveDocumentsAgentConfigDirectoryPath,C as resolveClineDataDir,f as resolveAgentsConfigDirPath,J as resolveAgentConfigSearchPaths,K as ensureParentDir,r as ensureHookLogDir,I as WORKFLOWS_CONFIG_DIRECTORY_NAME,g as SKILLS_CONFIG_DIRECTORY_NAME,G as RULES_CONFIG_DIRECTORY_NAME,E as HOOKS_CONFIG_DIRECTORY_NAME,y as CLINE_MCP_SETTINGS_FILE_NAME,l as AGENT_CONFIG_DIRECTORY_NAME};