codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/core/src/settings/settings-service.ts

@@ -0,0 +1,317 @@
+import { existsSync } from "node:fs";
+import { basename, isAbsolute, relative } from "node:path";
+import {
+	createUserInstructionConfigService,
+	type RuleConfig,
+	type SkillConfig,
+	type UserInstructionConfigService,
+	type WorkflowConfig,
+} from "../extensions/config";
+import { toggleSkillFrontmatter } from "../extensions/config/skill-frontmatter-toggle";
+import {
+	hasMcpSettingsFile,
+	resolveDefaultMcpSettingsPath,
+	resolveMcpServerRegistrations,
+	setMcpServerDisabled,
+} from "../extensions/mcp";
+import {
+	setToolDisabledGlobally,
+	toggleDisabledTool,
+} from "../services/global-settings";
+import { listPluginTools } from "../services/plugin-tools";
+import type {
+	CoreSettingsItem,
+	CoreSettingsListInput,
+	CoreSettingsMutationResult,
+	CoreSettingsSnapshot,
+	CoreSettingsToggleInput,
+} from "./types";
+
+function detectSource(
+	filePath: string,
+	workspaceRoot: string,
+): "global" | "workspace" {
+	if (!workspaceRoot) {
+		return "global";
+	}
+	const relativePath = relative(workspaceRoot, filePath);
+	return !relativePath.startsWith("..") && !isAbsolute(relativePath)
+		? "workspace"
+		: "global";
+}
+
+function toSorted<T extends CoreSettingsItem>(items: T[]): T[] {
+	return [...items].sort((a, b) => {
+		const sourceRank = (source: CoreSettingsItem["source"]): number => {
+			switch (source) {
+				case "workspace":
+				case "workspace-plugin":
+					return 0;
+				case "global":
+				case "global-plugin":
+					return 1;
+				case "builtin":
+					return 2;
+			}
+		};
+		if (a.source !== b.source) {
+			return sourceRank(a.source) - sourceRank(b.source);
+		}
+		return a.name.localeCompare(b.name);
+	});
+}
+
+function resolveWorkspaceRoot(input: CoreSettingsListInput): string {
+	return input.workspaceRoot?.trim() || input.cwd?.trim() || "";
+}
+
+async function withUserInstructionService<T>(
+	input: CoreSettingsListInput,
+	run: (service?: UserInstructionConfigService) => Promise<T>,
+): Promise<T> {
+	if (input.userInstructionService) {
+		return await run(input.userInstructionService);
+	}
+	const workspaceRoot = resolveWorkspaceRoot(input);
+	if (!workspaceRoot) {
+		return await run(undefined);
+	}
+	const cwd = input.cwd?.trim() || workspaceRoot;
+	const service = createUserInstructionConfigService({
+		skills: {
+			workspacePath: workspaceRoot,
+			includePluginSkills: true,
+			cwd,
+		},
+		rules: { workspacePath: workspaceRoot },
+		workflows: { workspacePath: workspaceRoot },
+	});
+	try {
+		await service.start();
+		return await run(service);
+	} finally {
+		service.stop();
+	}
+}
+
+function findSkillRecord(
+	service: UserInstructionConfigService | undefined,
+	input: CoreSettingsToggleInput,
+) {
+	if (!service) {
+		return undefined;
+	}
+	const records = service.listRecords<SkillConfig>("skill");
+	if (input.id) {
+		const match = records.find((record) => record.id === input.id);
+		if (match) {
+			return match;
+		}
+	}
+	for (const record of records) {
+		if (
+			record.filePath === input.path ||
+			record.item.name === input.name ||
+			record.id === input.name
+		) {
+			return record;
+		}
+	}
+	return undefined;
+}
+
+export class CoreSettingsService {
+	async list(input: CoreSettingsListInput = {}): Promise<CoreSettingsSnapshot> {
+		return await withUserInstructionService(input, async (service) => {
+			const workspaceRoot = resolveWorkspaceRoot(input);
+			const workflows: CoreSettingsItem[] = [];
+			const rules: CoreSettingsItem[] = [];
+			const skills: CoreSettingsItem[] = [];
+			const tools: CoreSettingsItem[] = [];
+			const mcp: CoreSettingsItem[] = [];
+
+			if (service) {
+				for (const record of service.listRecords<WorkflowConfig>("workflow")) {
+					const workflow = record.item;
+					workflows.push({
+						id: record.id,
+						name: workflow.name,
+						path: record.filePath,
+						enabled: workflow.disabled !== true,
+						kind: "workflow",
+						source: detectSource(record.filePath, workspaceRoot),
+						description: workflow.instructions,
+						toggleable: false,
+					});
+				}
+				for (const record of service.listRecords<RuleConfig>("rule")) {
+					const rule = record.item;
+					rules.push({
+						id: record.id,
+						name: rule.name,
+						path: record.filePath,
+						enabled: rule.disabled !== true,
+						kind: "rule",
+						source: detectSource(record.filePath, workspaceRoot),
+						description: rule.instructions,
+						toggleable: false,
+					});
+				}
+				for (const record of service.listRecords<SkillConfig>("skill")) {
+					const skill = record.item;
+					skills.push({
+						id: record.id,
+						name: skill.name,
+						path: record.filePath,
+						enabled: skill.disabled !== true,
+						kind: "skill",
+						source: detectSource(record.filePath, workspaceRoot),
+						description: skill.description,
+						toggleable: true,
+					});
+				}
+			}
+
+			if (workspaceRoot) {
+				try {
+					for (const pluginTool of await listPluginTools({
+						workspacePath: workspaceRoot,
+						cwd: input.cwd,
+						providerId: input.availabilityContext?.providerId,
+						modelId: input.availabilityContext?.modelId,
+					})) {
+						tools.push({
+							id: `${pluginTool.pluginName}:${pluginTool.name}:${pluginTool.path}`,
+							name: pluginTool.name,
+							path: pluginTool.path,
+							enabled: pluginTool.enabled,
+							kind: "tool",
+							source: pluginTool.source,
+							description: pluginTool.description,
+							toggleable: true,
+						});
+					}
+				} catch {
+					// Settings listing is best-effort; unreadable plugin roots should
+					// not hide rules, skills, workflows, or built-in tools.
+				}
+			}
+
+			const mcpSettingsPath = resolveDefaultMcpSettingsPath();
+			if (hasMcpSettingsFile({ filePath: mcpSettingsPath })) {
+				try {
+					for (const registration of resolveMcpServerRegistrations({
+						filePath: mcpSettingsPath,
+					})) {
+						mcp.push({
+							id: registration.name,
+							name: registration.name,
+							path: mcpSettingsPath,
+							enabled: registration.disabled !== true,
+							kind: "mcp",
+							source: detectSource(mcpSettingsPath, workspaceRoot),
+							description: registration.transport.type,
+							toggleable: true,
+						});
+					}
+				} catch {
+					// Settings listing is best-effort; unreadable MCP settings should
+					// not hide rules, skills, workflows, or tools.
+				}
+			}
+
+			return {
+				workflows: toSorted(workflows.filter((item) => existsSync(item.path))),
+				rules: toSorted(rules.filter((item) => existsSync(item.path))),
+				skills: toSorted(skills.filter((item) => existsSync(item.path))),
+				tools: toSorted(tools),
+				mcp: toSorted(mcp.filter((item) => existsSync(item.path))),
+			};
+		});
+	}
+
+	async toggle(
+		input: CoreSettingsToggleInput,
+	): Promise<CoreSettingsMutationResult> {
+		if (input.type === "skills") {
+			return await withUserInstructionService(input, async (service) => {
+				const record = findSkillRecord(service, input);
+				const filePath = record?.filePath;
+				if (!filePath) {
+					throw new Error(
+						`Unable to resolve skill setting '${input.id ?? input.name ?? basename(input.path ?? "")}'.`,
+					);
+				}
+				const currentEnabled =
+					record?.item && "disabled" in record.item
+						? (record.item as SkillConfig).disabled !== true
+						: undefined;
+				const enabled =
+					input.enabled ??
+					(currentEnabled !== undefined ? !currentEnabled : undefined);
+				if (enabled === undefined) {
+					throw new Error(
+						`Cannot determine toggle state for skill '${input.id ?? input.name ?? basename(input.path ?? "")}'; provide an explicit enabled value or a resolvable workspace context.`,
+					);
+				}
+				await toggleSkillFrontmatter({ filePath, enabled });
+				await service?.refreshType("skill");
+				return {
+					snapshot: await this.list({
+						...input,
+						userInstructionService: service,
+					}),
+					changedTypes: ["skills"],
+				};
+			});
+		}
+
+		if (input.type === "tools") {
+			if (!input.name?.trim()) {
+				throw new Error("Tool settings toggle requires a tool name.");
+			}
+			if (input.enabled === undefined) {
+				toggleDisabledTool(input.name);
+			} else {
+				setToolDisabledGlobally(input.name, !input.enabled);
+			}
+			return {
+				snapshot: await this.list(input),
+				changedTypes: ["tools"],
+			};
+		}
+
+		if (input.type === "mcp") {
+			const name = input.name?.trim() || input.id?.trim();
+			if (!name) {
+				throw new Error("MCP server settings toggle requires a server name.");
+			}
+			const filePath = input.path?.trim() || resolveDefaultMcpSettingsPath();
+			let targetEnabled = input.enabled;
+			if (targetEnabled === undefined) {
+				const current = resolveMcpServerRegistrations({ filePath }).find(
+					(registration) => registration.name === name,
+				);
+				if (!current) {
+					throw new Error(`Unknown MCP server: ${name}`);
+				}
+				targetEnabled = current.disabled === true;
+			}
+			setMcpServerDisabled({
+				filePath,
+				name,
+				disabled: !targetEnabled,
+			});
+			return {
+				snapshot: await this.list(input),
+				changedTypes: ["mcp"],
+			};
+		}
+
+		throw new Error(`Settings type '${input.type}' does not support toggles.`);
+	}
+}
+
+export function createCoreSettingsService(): CoreSettingsService {
+	return new CoreSettingsService();
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/settings/types.ts

@@ -0,0 +1,67 @@
+import type { UserInstructionConfigService } from "../extensions/config";
+import type { BuiltinToolAvailabilityContext } from "../extensions/tools";
+
+export type CoreSettingsType =
+	| "skills"
+	| "workflows"
+	| "rules"
+	| "tools"
+	| "mcp";
+
+export type CoreSettingsItemKind =
+	| "skill"
+	| "workflow"
+	| "rule"
+	| "tool"
+	| "mcp";
+
+export type CoreSettingsItemSource =
+	| "global"
+	| "workspace"
+	| "builtin"
+	| "global-plugin"
+	| "workspace-plugin";
+
+export interface CoreSettingsItem {
+	id: string;
+	name: string;
+	path: string;
+	kind: CoreSettingsItemKind;
+	source: CoreSettingsItemSource;
+	enabled?: boolean;
+	description?: string;
+	toggleable?: boolean;
+}
+
+export interface CoreSettingsSnapshot {
+	workflows: CoreSettingsItem[];
+	rules: CoreSettingsItem[];
+	skills: CoreSettingsItem[];
+	tools: CoreSettingsItem[];
+	mcp: CoreSettingsItem[];
+}
+
+export interface CoreSettingsListInput {
+	cwd?: string;
+	workspaceRoot?: string;
+	userInstructionService?: UserInstructionConfigService;
+	availabilityContext?: BuiltinToolAvailabilityContext;
+}
+
+export interface CoreSettingsToggleInput extends CoreSettingsListInput {
+	type: CoreSettingsType;
+	id?: string;
+	path?: string;
+	name?: string;
+	enabled?: boolean;
+}
+
+export interface CoreSettingsMutationResult {
+	snapshot: CoreSettingsSnapshot;
+	changedTypes: CoreSettingsType[];
+}
+
+export interface ClineCoreSettingsApi {
+	list(input?: CoreSettingsListInput): Promise<CoreSettingsSnapshot>;
+	toggle(input: CoreSettingsToggleInput): Promise<CoreSettingsMutationResult>;
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/types/chat-schema.ts

@@ -0,0 +1,90 @@
+import { z } from "zod";
+
+export const ChatSessionConfigSchema = z.object({
+	workspaceRoot: z.string().min(1),
+	cwd: z.string().optional(),
+	provider: z.string().min(1),
+	model: z.string().min(1),
+	mode: z.enum(["act", "plan"]).default("act"),
+	apiKey: z.string(),
+	systemPrompt: z.string().optional(),
+	rules: z.string().optional(),
+	maxIterations: z.number().int().positive().optional(),
+	enableTools: z.boolean(),
+	enableSpawn: z.boolean().optional(),
+	enableTeams: z.boolean().optional(),
+	autoApproveTools: z.boolean().optional(),
+	missionStepInterval: z.number().int().positive().optional(),
+	missionTimeIntervalMs: z.number().int().positive().optional(),
+});
+
+export const ChatSessionStatusSchema = z.enum([
+	"idle",
+	"starting",
+	"running",
+	"pending",
+	"stopping",
+	"completed",
+	"cancelled",
+	"failed",
+	"error",
+]);
+
+export const ChatMessageRoleSchema = z.enum([
+	"user",
+	"assistant",
+	"tool",
+	"system",
+	"status",
+	"error",
+]);
+
+export const ChatMessageSchema = z.object({
+	id: z.string().min(1),
+	sessionId: z.string().nullable(),
+	role: ChatMessageRoleSchema,
+	content: z.string(),
+	createdAt: z.number().int().nonnegative(),
+	meta: z
+		.object({
+			stream: z.enum(["stdout", "stderr"]).optional(),
+			toolName: z.string().optional(),
+			iteration: z.number().int().nonnegative().optional(),
+			agentId: z.string().optional(),
+			conversationId: z.string().optional(),
+			hookEventName: z.string().optional(),
+			inputTokens: z.number().int().nonnegative().optional(),
+			outputTokens: z.number().int().nonnegative().optional(),
+			checkpoint: z
+				.object({
+					ref: z.string(),
+					createdAt: z.number().int().nonnegative(),
+					runCount: z.number().int().positive(),
+					kind: z.enum(["stash", "commit"]).optional(),
+				})
+				.optional(),
+		})
+		.optional(),
+});
+
+export const ChatSummarySchema = z.object({
+	toolCalls: z.number().int().nonnegative(),
+	tokensIn: z.number().int().nonnegative(),
+	tokensOut: z.number().int().nonnegative(),
+});
+
+export const ChatViewStateSchema = z.object({
+	sessionId: z.string().nullable(),
+	status: ChatSessionStatusSchema,
+	config: ChatSessionConfigSchema,
+	messages: z.array(ChatMessageSchema),
+	rawTranscript: z.string(),
+	error: z.string().nullable(),
+	summary: ChatSummarySchema,
+});
+
+export type ChatSessionConfig = z.infer<typeof ChatSessionConfigSchema>;
+export type ChatSessionStatus = z.infer<typeof ChatSessionStatusSchema>;
+export type ChatMessage = z.infer<typeof ChatMessageSchema>;
+export type ChatSummary = z.infer<typeof ChatSummarySchema>;
+export type ChatViewState = z.infer<typeof ChatViewStateSchema>;

codna/agent-core/vendor/cline/sdk/packages/core/src/types/common.ts

@@ -0,0 +1,54 @@
+import { SESSION_STATUS_VALUES } from "@cline/shared";
+
+export const SESSION_STATUSES = SESSION_STATUS_VALUES;
+
+export type SessionStatus = (typeof SESSION_STATUSES)[number];
+
+export const NON_TERMINAL_SESSION_STATUSES = [
+	"idle",
+	"running",
+	"pending",
+] as const satisfies readonly SessionStatus[];
+
+export type NonTerminalSessionStatus =
+	(typeof NON_TERMINAL_SESSION_STATUSES)[number];
+
+export type TerminalSessionStatus = Exclude<
+	SessionStatus,
+	NonTerminalSessionStatus
+>;
+
+export function isTerminalSessionStatus(
+	status: SessionStatus,
+): status is TerminalSessionStatus {
+	return !NON_TERMINAL_SESSION_STATUSES.includes(
+		status as NonTerminalSessionStatus,
+	);
+}
+
+export function isNonTerminalSessionStatus(
+	status: SessionStatus,
+): status is NonTerminalSessionStatus {
+	return !isTerminalSessionStatus(status);
+}
+
+export const SessionSource = {
+	CORE: "core",
+	CLI: "cli",
+	SUBAGENT: "subagent",
+	DESKTOP: "desktop",
+	KANBAN: "kanban",
+	API: "api",
+	WEB: "web",
+	VSCODE: "vscode",
+	ENTERPRISE: "enterprise",
+	IDE: "ide",
+	JETBRAINS: "jetbrains",
+	NEOVIM: "neovim",
+	UNKNOWN: "unknown",
+} as const;
+
+export type BuiltinSessionSource =
+	(typeof SessionSource)[keyof typeof SessionSource];
+
+export type SessionSource = BuiltinSessionSource | (string & {});