codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/shared/src/automation/index.ts

@@ -0,0 +1,31 @@
+export type {
+	AutomationEventFrontmatter,
+	AutomationOneOffFrontmatter,
+	AutomationScheduleFrontmatter,
+} from "./schemas";
+export {
+	AutomationEventFrontmatterSchema,
+	AutomationOneOffFrontmatterSchema,
+	AutomationScheduleFrontmatterSchema,
+	EVENT_ONLY_FIELDS,
+	SCHEDULE_ONLY_FIELDS,
+} from "./schemas";
+export type {
+	AutomationEventEnvelope,
+	AutomationEventSpec,
+	AutomationOneOffSpec,
+	AutomationRunStatus,
+	AutomationRunTriggerKind,
+	AutomationScheduleSpec,
+	AutomationSpec,
+	AutomationSpecCommon,
+	AutomationSpecParseStatus,
+	AutomationSpecSource,
+	AutomationTriggerKind,
+	ParsedSpec,
+	ParsedSpecError,
+	ParsedSpecOk,
+	ParseIssue,
+	ParseIssueDetail,
+	ParseIssueKind,
+} from "./types";

codna/agent-core/vendor/cline/sdk/packages/shared/src/automation/schemas.ts

@@ -0,0 +1,99 @@
+import { z } from "zod";
+
+/**
+ * Zod schemas for automation spec frontmatter. Used by the parser in
+ * `@cline/core` to validate frontmatter shape before normalization.
+ *
+ * The schemas are deliberately permissive: they accept the raw parsed YAML
+ * object and let the parser layer apply normalization rules (trim, default
+ * enabled, resolve title, body->prompt fallback, etc).
+ */
+
+const nonEmptyString = z.string().min(1);
+
+const tagsSchema = z.array(z.string()).optional();
+
+const metadataSchema = z.record(z.string(), z.unknown()).optional();
+
+const modeSchema = z.enum(["act", "plan", "yolo", "zen"]).optional();
+
+const modelSelectionSchema = z
+	.object({
+		providerId: nonEmptyString,
+		modelId: z.string().optional(),
+	})
+	.optional();
+
+/**
+ * Fields accepted across every trigger kind. Trigger-specific fields live on
+ * their respective discriminants and are rejected when they appear on the
+ * wrong kind.
+ */
+const commonFrontmatterFields = {
+	id: z.string().optional(),
+	title: z.string().optional(),
+	prompt: z.string().optional(),
+	workspaceRoot: z.string().optional(),
+	cwd: z.string().optional(),
+	modelSelection: modelSelectionSchema,
+	systemPrompt: z.string().optional(),
+	mode: modeSchema,
+	timeoutSeconds: z.number().int().positive().optional(),
+	maxIterations: z.number().int().positive().optional(),
+	tags: tagsSchema,
+	enabled: z.boolean().optional(),
+	metadata: metadataSchema,
+} as const;
+
+export const AutomationOneOffFrontmatterSchema = z
+	.object({
+		...commonFrontmatterFields,
+	})
+	.strict();
+
+export const AutomationScheduleFrontmatterSchema = z
+	.object({
+		...commonFrontmatterFields,
+		schedule: nonEmptyString,
+		timezone: z.string().optional(),
+	})
+	.strict();
+
+export const AutomationEventFrontmatterSchema = z
+	.object({
+		...commonFrontmatterFields,
+		event: nonEmptyString,
+		filters: z.record(z.string(), z.unknown()).optional(),
+		debounceSeconds: z.number().int().nonnegative().optional(),
+		dedupeWindowSeconds: z.number().int().nonnegative().optional(),
+		cooldownSeconds: z.number().int().nonnegative().optional(),
+		maxParallel: z.number().int().positive().optional(),
+	})
+	.strict();
+
+/**
+ * Field names that are only valid on schedule specs.
+ */
+export const SCHEDULE_ONLY_FIELDS = ["schedule", "timezone"] as const;
+
+/**
+ * Field names that are only valid on event specs.
+ */
+export const EVENT_ONLY_FIELDS = [
+	"event",
+	"filters",
+	"debounceSeconds",
+	"dedupeWindowSeconds",
+	"cooldownSeconds",
+	"maxParallel",
+] as const;
+
+export type AutomationOneOffFrontmatter = z.infer<
+	typeof AutomationOneOffFrontmatterSchema
+>;
+export type AutomationScheduleFrontmatter = z.infer<
+	typeof AutomationScheduleFrontmatterSchema
+>;
+export type AutomationEventFrontmatter = z.infer<
+	typeof AutomationEventFrontmatterSchema
+>;

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

@@ -0,0 +1,187 @@
+import type { GatewayModelSelection } from "../llms/gateway";
+import type { AgentMode } from "../session/runtime-config";
+
+/**
+ * Trigger kinds supported by the automation subsystem.
+ *
+ * - `one_off`: a single run materialized from a `.cline/cron/*.md` spec.
+ * - `schedule`: recurring runs materialized from a `.cline/cron/*.cron.md` spec.
+ * - `event`: reactive runs materialized from a `.cline/cron/events/*.event.md`
+ *   spec. Event-driven specs are defined here for contract completeness but
+ *   runtime matching lives in a later feature.
+ */
+export type AutomationTriggerKind = "one_off" | "schedule" | "event";
+
+/**
+ * Trigger kinds persisted on `cron_runs`. Event-driven, manual, and retry
+ * triggers are all first-class run sources in addition to the spec-defined
+ * `one_off` and `schedule` kinds.
+ */
+export type AutomationRunTriggerKind =
+	| "one_off"
+	| "schedule"
+	| "event"
+	| "manual"
+	| "retry";
+
+/**
+ * Lifecycle status of a queued run row in `cron_runs`.
+ */
+export type AutomationRunStatus =
+	| "queued"
+	| "running"
+	| "done"
+	| "failed"
+	| "cancelled";
+
+/**
+ * Parse status persisted on a `cron_specs` row.
+ */
+export type AutomationSpecParseStatus = "valid" | "invalid";
+
+/**
+ * Common fields shared by every automation spec after parsing.
+ *
+ * `id` is the stable external identity derived from the frontmatter `id` field
+ * when present, or from the normalized relative source path as a fallback.
+ */
+export interface AutomationSpecCommon {
+	/** Stable external identity: frontmatter id, else normalized relative path. */
+	id: string;
+	/** Optional explicit frontmatter `id` (undefined when falling back to path). */
+	externalId?: string;
+	/** Human-readable title used in reports and list APIs. */
+	title: string;
+	/** Prompt text: frontmatter `prompt` if provided, otherwise the markdown body. */
+	prompt: string;
+	/** Absolute workspace root the automation run executes against. */
+	workspaceRoot: string;
+	/** Working directory inside the workspace (defaults to workspaceRoot at runtime). */
+	cwd?: string;
+	/** Optional model selection; when omitted the runtime default is used. */
+	modelSelection?: GatewayModelSelection;
+	/** System prompt override. */
+	systemPrompt?: string;
+	/** Agent mode. Defaults to `act` at runtime if omitted. */
+	mode?: AgentMode;
+	/** Hard timeout enforced by the runner. */
+	timeoutSeconds?: number;
+	/** Maximum agent iterations. */
+	maxIterations?: number;
+	/** Free-form tags. */
+	tags?: readonly string[];
+	/** Whether the spec is enabled. Defaults to `true`. */
+	enabled: boolean;
+	/** Arbitrary user metadata; stored verbatim as JSON. */
+	metadata?: Readonly<Record<string, unknown>>;
+}
+
+export interface AutomationOneOffSpec extends AutomationSpecCommon {
+	triggerKind: "one_off";
+}
+
+export interface AutomationScheduleSpec extends AutomationSpecCommon {
+	triggerKind: "schedule";
+	/** Cron expression (5 or 6 fields, parser validated by the scheduler). */
+	schedule: string;
+	/** IANA timezone name. Optional; falls back to runtime default. */
+	timezone?: string;
+}
+
+/**
+ * Event-driven spec. Feature 2 owns the matcher; Feature 1 only needs the
+ * contract so `.event.md` specs parsed later surface the expected shape.
+ */
+export interface AutomationEventSpec extends AutomationSpecCommon {
+	triggerKind: "event";
+	event: string;
+	filters?: Readonly<Record<string, unknown>>;
+	debounceSeconds?: number;
+	dedupeWindowSeconds?: number;
+	cooldownSeconds?: number;
+	maxParallel?: number;
+}
+
+/**
+ * Discriminated union of all automation specs.
+ */
+export type AutomationSpec =
+	| AutomationOneOffSpec
+	| AutomationScheduleSpec
+	| AutomationEventSpec;
+
+/**
+ * Normalized automation event envelope. Feature 2 will flesh out matching on
+ * top of this contract; Feature 1 ships the scaffold so downstream modules can
+ * reference it without cyclic dependencies.
+ */
+export interface AutomationEventEnvelope {
+	eventId: string;
+	eventType: string;
+	source: string;
+	subject?: string;
+	occurredAt: string;
+	workspaceRoot?: string;
+	payload: unknown;
+	attributes?: Readonly<Record<string, unknown>>;
+	dedupeKey?: string;
+}
+
+/**
+ * Source-file metadata passed into the parser. Filesystem I/O (reading the
+ * file, hashing the bytes, stat-ing mtime) happens in core; the parser stays
+ * pure and takes these values as inputs.
+ */
+export interface AutomationSpecSource {
+	/**
+	 * POSIX-normalized path of the source file relative to `.cline/cron/`.
+	 * Used as the identity fallback and persisted in `cron_specs.source_path`.
+	 */
+	normalizedRelativePath: string;
+	/** Bare filename (e.g. `repo-cleanup.md`). */
+	filename: string;
+	/** File mtime in milliseconds since the epoch. */
+	mtimeMs: number;
+	/** Content hash (hex sha256) of the raw file bytes. */
+	hash: string;
+}
+
+export interface ParsedSpecOk {
+	ok: true;
+	spec: AutomationSpec;
+	source: AutomationSpecSource;
+	/** Non-fatal parser warnings. */
+	warnings: readonly ParseIssueDetail[];
+}
+
+export interface ParsedSpecError {
+	ok: false;
+	source: AutomationSpecSource;
+	issue: ParseIssue;
+}
+
+export type ParsedSpec = ParsedSpecOk | ParsedSpecError;
+
+/**
+ * Categorization of parser issues. `unsupported` is reserved for spec shapes
+ * that are syntactically valid but intentionally deferred (e.g. `.event.md`
+ * before Feature 2 lands). All other kinds are fatal for that file.
+ */
+export type ParseIssueKind =
+	| "yaml"
+	| "schema"
+	| "missing_required"
+	| "conflicting_fields"
+	| "empty_prompt"
+	| "unsupported";
+
+export interface ParseIssueDetail {
+	field?: string;
+	message: string;
+}
+
+export interface ParseIssue {
+	kind: ParseIssueKind;
+	message: string;
+	details?: readonly ParseIssueDetail[];
+}

codna/agent-core/vendor/cline/sdk/packages/shared/src/connectors/events.ts

@@ -0,0 +1,73 @@
+import { z } from "zod";
+
+export const ConnectorHookEventNameSchema = z.enum([
+	"connector.started",
+	"connector.stopping",
+	"session.authorize",
+	"message.received",
+	"message.denied",
+	"message.completed",
+	"message.failed",
+	"session.started",
+	"session.reused",
+	"session.reset",
+	"schedule.delivery.started",
+	"schedule.delivery.sent",
+	"schedule.delivery.failed",
+]);
+
+export type ConnectorHookEventName = z.infer<
+	typeof ConnectorHookEventNameSchema
+>;
+
+export const ConnectorEventActorSchema = z.object({
+	id: z.string().optional(),
+	label: z.string().optional(),
+	role: z.string().optional(),
+	participantKey: z.string().optional(),
+	participantLabel: z.string().optional(),
+	platformUserId: z.string().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export const ConnectorEventContextSchema = z.object({
+	source: z.string(),
+	sourceEvent: z.string(),
+	threadId: z.string(),
+	channelId: z.string(),
+	isDM: z.boolean(),
+	sessionId: z.string().optional(),
+	workspaceRoot: z.string().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export const ConnectorAuthorizationRequestSchema = z.object({
+	actor: ConnectorEventActorSchema,
+	context: ConnectorEventContextSchema,
+	payload: z.record(z.string(), z.unknown()).optional(),
+});
+
+export const ConnectorAuthorizationDecisionSchema = z.object({
+	action: z.enum(["allow", "deny"]).default("allow"),
+	message: z.string().optional(),
+	reason: z.string().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export const ConnectorHookEventSchema = z.object({
+	adapter: z.string(),
+	botUserName: z.string().optional(),
+	event: ConnectorHookEventNameSchema,
+	payload: z.record(z.string(), z.unknown()),
+	ts: z.string(),
+});
+
+export type ConnectorHookEvent = z.infer<typeof ConnectorHookEventSchema>;
+export type ConnectorEventActor = z.infer<typeof ConnectorEventActorSchema>;
+export type ConnectorEventContext = z.infer<typeof ConnectorEventContextSchema>;
+export type ConnectorAuthorizationRequest = z.infer<
+	typeof ConnectorAuthorizationRequestSchema
+>;
+export type ConnectorAuthorizationDecision = z.infer<
+	typeof ConnectorAuthorizationDecisionSchema
+>;

codna/agent-core/vendor/cline/sdk/packages/shared/src/connectors/options.ts

@@ -0,0 +1,190 @@
+export type ConnectWhatsAppOptions = {
+	userName: string;
+	phoneNumberId?: string;
+	accessToken?: string;
+	appSecret?: string;
+	verifyToken?: string;
+	apiVersion?: string;
+	cwd: string;
+	model?: string;
+	provider?: string;
+	apiKey?: string;
+	systemPrompt?: string;
+	mode: "act" | "plan";
+	interactive: boolean;
+	maxIterations?: number;
+	enableTools: boolean;
+	rpcAddress: string;
+	hookCommand?: string;
+	port: number;
+	host: string;
+	baseUrl: string;
+};
+
+export type WhatsAppConnectorState = {
+	instanceKey: string;
+	userName: string;
+	phoneNumberId?: string;
+	pid: number;
+	rpcAddress: string;
+	port: number;
+	baseUrl: string;
+	startedAt: string;
+};
+
+export type ConnectTelegramOptions = {
+	botToken: string;
+	botUsername?: string;
+	cwd: string;
+	model?: string;
+	provider?: string;
+	apiKey?: string;
+	systemPrompt?: string;
+	mode: "act" | "plan";
+	interactive: boolean;
+	maxIterations?: number;
+	enableTools: boolean;
+	rpcAddress: string;
+	hookCommand?: string;
+};
+
+export type TelegramConnectorState = {
+	botUsername: string;
+	botId?: string;
+	pid: number;
+	rpcAddress: string;
+	startedAt: string;
+};
+
+export type ConnectSlackOptions = {
+	userName: string;
+	connectionMode: "webhook" | "socket";
+	botToken?: string;
+	signingSecret?: string;
+	appToken?: string;
+	clientId?: string;
+	clientSecret?: string;
+	encryptionKey?: string;
+	installationKeyPrefix?: string;
+	cwd: string;
+	model?: string;
+	provider?: string;
+	apiKey?: string;
+	systemPrompt?: string;
+	mode: "act" | "plan";
+	interactive: boolean;
+	maxIterations?: number;
+	enableTools: boolean;
+	rpcAddress: string;
+	hookCommand?: string;
+	port: number;
+	host: string;
+	baseUrl?: string;
+};
+
+export type SlackConnectorState = {
+	userName: string;
+	connectionMode?: "webhook" | "socket";
+	pid: number;
+	rpcAddress: string;
+	port?: number;
+	baseUrl?: string;
+	startedAt: string;
+};
+
+export type ConnectDiscordOptions = {
+	userName: string;
+	applicationId: string;
+	botToken: string;
+	publicKey: string;
+	ownerUserId?: string;
+	allowBotAuthors: boolean;
+	mentionRoleIds?: string[];
+	cwd: string;
+	model?: string;
+	provider?: string;
+	apiKey?: string;
+	systemPrompt?: string;
+	mode: "act" | "plan";
+	interactive: boolean;
+	maxIterations?: number;
+	enableTools: boolean;
+	rpcAddress: string;
+	hookCommand?: string;
+	port: number;
+	host: string;
+	baseUrl: string;
+};
+
+export type DiscordConnectorState = {
+	userName: string;
+	applicationId: string;
+	pid: number;
+	rpcAddress: string;
+	port: number;
+	baseUrl: string;
+	startedAt: string;
+};
+
+export type ConnectGoogleChatOptions = {
+	userName: string;
+	cwd: string;
+	model?: string;
+	provider?: string;
+	apiKey?: string;
+	systemPrompt?: string;
+	mode: "act" | "plan";
+	interactive: boolean;
+	maxIterations?: number;
+	enableTools: boolean;
+	rpcAddress: string;
+	hookCommand?: string;
+	port: number;
+	host: string;
+	baseUrl: string;
+	pubsubTopic?: string;
+	impersonateUser?: string;
+	useApplicationDefaultCredentials: boolean;
+	credentialsJson?: string;
+};
+
+export type GoogleChatConnectorState = {
+	userName: string;
+	pid: number;
+	rpcAddress: string;
+	port: number;
+	baseUrl: string;
+	startedAt: string;
+};
+
+export type ConnectLinearOptions = {
+	userName: string;
+	apiKey?: string;
+	clientId?: string;
+	clientSecret?: string;
+	accessToken?: string;
+	webhookSecret: string;
+	cwd: string;
+	model?: string;
+	provider?: string;
+	apiProviderKey?: string;
+	systemPrompt?: string;
+	mode: "act" | "plan";
+	interactive: boolean;
+	maxIterations?: number;
+	enableTools: boolean;
+	rpcAddress: string;
+	hookCommand?: string;
+	port: number;
+	host: string;
+	baseUrl: string;
+};
+
+export type LinearConnectorState = {
+	userName: string;
+	pid: number;
+	rpcAddress: string;
+	port: number;
+	baseUrl: string;
+	startedAt: string;
+};

codna/agent-core/vendor/cline/sdk/packages/shared/src/cron/cron-spec-types.ts

@@ -0,0 +1,104 @@
+/**
+ * Shared types describing automation cron specs parsed from Markdown files.
+ * Split out from `@cline/core` so the parser can live in `shared` where
+ * multiple consumers (hub daemon, CLI tools, enterprise adapters) can validate
+ * the same `.cline/cron/` spec format without pulling in core's stateful
+ * orchestration layer.
+ */
+
+export type CronTriggerKind = "one_off" | "schedule" | "event";
+
+/**
+ * Which trigger kind was inferred from the source file path.
+ * - `*.cron.md` -> schedule
+ * - `events/*.event.md` -> event
+ * - everything else under `.cline/cron/*.md` -> one_off
+ */
+export interface CronSpecModelSelection {
+	providerId?: string;
+	modelId?: string;
+}
+
+export type CronSpecMode = "act" | "plan" | "yolo";
+export type CronSpecExtensionKind = "rules" | "skills" | "plugins";
+
+export interface CronSpecCommonFields {
+	/** Optional explicit id from frontmatter; falls back to relative path. */
+	id?: string;
+	title?: string;
+	prompt?: string;
+	workspaceRoot?: string;
+	mode?: CronSpecMode;
+	systemPrompt?: string;
+	modelSelection?: CronSpecModelSelection;
+	maxIterations?: number;
+	timeoutSeconds?: number;
+	tools?: string[];
+	notesDirectory?: string;
+	extensions?: CronSpecExtensionKind[];
+	source?: string;
+	tags?: string[];
+	enabled?: boolean;
+	metadata?: Record<string, unknown>;
+}
+
+export interface CronOneOffSpec extends CronSpecCommonFields {
+	triggerKind: "one_off";
+}
+
+export interface CronScheduleSpec extends CronSpecCommonFields {
+	triggerKind: "schedule";
+	schedule: string;
+	timezone?: string;
+}
+
+export interface CronEventSpec extends CronSpecCommonFields {
+	triggerKind: "event";
+	event: string;
+	filters?: Record<string, unknown>;
+	debounceSeconds?: number;
+	dedupeWindowSeconds?: number;
+	cooldownSeconds?: number;
+	maxParallel?: number;
+}
+
+export type CronSpec = CronOneOffSpec | CronScheduleSpec | CronEventSpec;
+
+/**
+ * Result of parsing one file. Always produces a record — even invalid specs
+ * are surfaced so the store can durably record parse errors rather than
+ * silently dropping state.
+ */
+export interface CronSpecParseResult {
+	/** Stable external identity: frontmatter `id` or normalized relative path. */
+	externalId: string;
+	/** Normalized posix-style path relative to `.cline/cron/`. */
+	relativePath: string;
+	/** Trigger kind inferred from file naming. */
+	triggerKind: CronTriggerKind;
+	/** Raw file body (without frontmatter). */
+	body: string;
+	/** sha256 of canonical frontmatter JSON + body. */
+	contentHash: string;
+	/** When the parse succeeded. */
+	spec?: CronSpec;
+	/** Parse error message when the spec is invalid. */
+	error?: string;
+}
+
+/**
+ * Normalized automation event envelope. Used by the event-driven feature
+ * (Feature 2) but defined here so core, adapters, and shared validation
+ * agree on the shape from day one.
+ */
+export interface AutomationEventEnvelope {
+	eventId: string;
+	eventType: string;
+	source: string;
+	subject?: string;
+	occurredAt: string;
+	workspaceRoot?: string;
+	payload?: Record<string, unknown>;
+	attributes?: Record<string, unknown>;
+	dedupeKey?: string;
+}

codna/agent-core/vendor/cline/sdk/packages/shared/src/cron/index.ts

@@ -0,0 +1,13 @@
+export type {
+	AutomationEventEnvelope,
+	CronEventSpec,
+	CronOneOffSpec,
+	CronScheduleSpec,
+	CronSpec,
+	CronSpecCommonFields,
+	CronSpecExtensionKind,
+	CronSpecMode,
+	CronSpecModelSelection,
+	CronSpecParseResult,
+	CronTriggerKind,
+} from "./cron-spec-types";

codna/agent-core/vendor/cline/sdk/packages/shared/src/db/index.ts

@@ -0,0 +1,14 @@
+export type {
+	SessionSchemaOptions,
+	SqliteDb,
+	SqliteStatement,
+} from "./sqlite-db";
+export {
+	asBool,
+	asOptionalString,
+	asString,
+	ensureSessionSchema,
+	loadSqliteDb,
+	nowIso,
+	toBoolInt,
+} from "./sqlite-db";