codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/core/src/cron/schedule/scheduler.ts

@@ -0,0 +1,373 @@
+function parseCronField(
+	token: string,
+	min: number,
+	max: number,
+	names?: readonly string[],
+): number[] {
+	const results = new Set<number>();
+
+	function resolveValue(raw: string): number {
+		const lower = raw.toLowerCase();
+		if (names) {
+			const index = names.indexOf(lower);
+			if (index !== -1) {
+				return index + min;
+			}
+		}
+		const value = Number(raw);
+		if (!Number.isInteger(value) || value < min || value > max) {
+			throw new Error(`Invalid cron value "${raw}" for range [${min}-${max}]`);
+		}
+		return value;
+	}
+
+	for (const part of token.split(",")) {
+		if (part === "*") {
+			for (let value = min; value <= max; value += 1) {
+				results.add(value);
+			}
+			continue;
+		}
+
+		const stepSeparator = part.indexOf("/");
+		if (stepSeparator !== -1) {
+			const rangePart = part.slice(0, stepSeparator);
+			const step = Number(part.slice(stepSeparator + 1));
+			if (!Number.isInteger(step) || step < 1) {
+				throw new Error(`Invalid step "${part.slice(stepSeparator + 1)}"`);
+			}
+			let from = min;
+			let to = max;
+			if (rangePart !== "*") {
+				const dashIndex = rangePart.indexOf("-");
+				if (dashIndex !== -1) {
+					from = resolveValue(rangePart.slice(0, dashIndex));
+					to = resolveValue(rangePart.slice(dashIndex + 1));
+				} else {
+					from = resolveValue(rangePart);
+				}
+			}
+			if (from > to) {
+				throw new Error(`Invalid cron range "${rangePart}"`);
+			}
+			for (let value = from; value <= to; value += step) {
+				results.add(value);
+			}
+			continue;
+		}
+
+		const dashIndex = part.indexOf("-");
+		if (dashIndex !== -1) {
+			const from = resolveValue(part.slice(0, dashIndex));
+			const to = resolveValue(part.slice(dashIndex + 1));
+			if (from > to) {
+				throw new Error(`Invalid cron range "${part}"`);
+			}
+			for (let value = from; value <= to; value += 1) {
+				results.add(value);
+			}
+			continue;
+		}
+
+		results.add(resolveValue(part));
+	}
+
+	return [...results].sort((left, right) => left - right);
+}
+
+const MONTH_NAMES = [
+	"jan",
+	"feb",
+	"mar",
+	"apr",
+	"may",
+	"jun",
+	"jul",
+	"aug",
+	"sep",
+	"oct",
+	"nov",
+	"dec",
+] as const;
+
+const DOW_NAMES = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"] as const;
+
+export interface ParsedCron {
+	minutes: number[];
+	hours: number[];
+	daysOfMonth: number[];
+	months: number[];
+	daysOfWeek: number[];
+}
+
+interface CronDateParts {
+	month: number;
+	dayOfMonth: number;
+	dayOfWeek: number;
+	hour: number;
+	minute: number;
+}
+
+function getRequiredField(
+	fields: readonly string[],
+	index: number,
+	pattern: string,
+): string {
+	const value = fields[index];
+	if (typeof value !== "string") {
+		throw new Error(
+			`Invalid cron pattern "${pattern}": missing field ${index + 1}`,
+		);
+	}
+	return value;
+}
+
+function getFirstCronValue(values: readonly number[], label: string): number {
+	const value = values[0];
+	if (typeof value !== "number") {
+		throw new Error(`Invalid cron pattern: no values parsed for ${label}`);
+	}
+	return value;
+}
+
+export function parseCron(pattern: string): ParsedCron {
+	const fields = pattern.trim().split(/\s+/);
+	if (fields.length !== 5) {
+		throw new Error(
+			`Invalid cron pattern "${pattern}": expected 5 fields, got ${fields.length}`,
+		);
+	}
+	return {
+		minutes: parseCronField(getRequiredField(fields, 0, pattern), 0, 59),
+		hours: parseCronField(getRequiredField(fields, 1, pattern), 0, 23),
+		daysOfMonth: parseCronField(getRequiredField(fields, 2, pattern), 1, 31),
+		months: parseCronField(
+			getRequiredField(fields, 3, pattern),
+			1,
+			12,
+			MONTH_NAMES,
+		),
+		daysOfWeek: parseCronField(
+			getRequiredField(fields, 4, pattern),
+			0,
+			6,
+			DOW_NAMES,
+		),
+	};
+}
+
+export function validateCronPattern(pattern: string): void {
+	parseCron(pattern);
+}
+
+export function validateCronSchedule(
+	pattern: string,
+	timezone?: string,
+	after: number = Date.now(),
+): void {
+	getNextCronTime(pattern, after, timezone);
+}
+
+const TIMEZONE_FORMATTERS = new Map<string, Intl.DateTimeFormat>();
+const DOW_BY_SHORT_NAME = new Map(
+	DOW_NAMES.map((name, index) => [name, index] as const),
+);
+
+function normalizeTimezone(timezone: string | undefined): string | undefined {
+	const trimmed = timezone?.trim();
+	return trimmed ? trimmed : undefined;
+}
+
+function getTimezoneFormatter(timezone: string): Intl.DateTimeFormat {
+	const existing = TIMEZONE_FORMATTERS.get(timezone);
+	if (existing) return existing;
+	const formatter = new Intl.DateTimeFormat("en-US", {
+		timeZone: timezone,
+		calendar: "gregory",
+		numberingSystem: "latn",
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		weekday: "short",
+		hour: "2-digit",
+		minute: "2-digit",
+		hourCycle: "h23",
+	});
+	TIMEZONE_FORMATTERS.set(timezone, formatter);
+	return formatter;
+}
+
+export function validateTimezone(timezone: string | undefined): void {
+	const normalized = normalizeTimezone(timezone);
+	if (!normalized) return;
+	getTimezoneFormatter(normalized).format(new Date());
+}
+
+function getZonedCronDateParts(
+	timestampMs: number,
+	timezone: string,
+): CronDateParts {
+	const parts = getTimezoneFormatter(timezone).formatToParts(
+		new Date(timestampMs),
+	);
+	const byType = new Map(parts.map((part) => [part.type, part.value]));
+	const weekdayRaw = byType.get("weekday")?.toLowerCase().slice(0, 3) ?? "";
+	const dayOfWeek = DOW_BY_SHORT_NAME.get(
+		weekdayRaw as (typeof DOW_NAMES)[number],
+	);
+	if (dayOfWeek === undefined) {
+		throw new Error(`Unable to resolve weekday for timezone "${timezone}"`);
+	}
+	return {
+		month: Number(byType.get("month")),
+		dayOfMonth: Number(byType.get("day")),
+		dayOfWeek,
+		hour: Number(byType.get("hour")),
+		minute: Number(byType.get("minute")),
+	};
+}
+
+function getLocalCronDateParts(timestampMs: number): CronDateParts {
+	const date = new Date(timestampMs);
+	return {
+		month: date.getMonth() + 1,
+		dayOfMonth: date.getDate(),
+		dayOfWeek: date.getDay(),
+		hour: date.getHours(),
+		minute: date.getMinutes(),
+	};
+}
+
+function cronMatchesParts(cron: ParsedCron, parts: CronDateParts): boolean {
+	return (
+		cron.months.includes(parts.month) &&
+		cron.daysOfMonth.includes(parts.dayOfMonth) &&
+		cron.daysOfWeek.includes(parts.dayOfWeek) &&
+		cron.hours.includes(parts.hour) &&
+		cron.minutes.includes(parts.minute)
+	);
+}
+
+function getNextCronTimeByMinuteScan(
+	pattern: string,
+	after: number,
+	timezone: string,
+): number {
+	const cron = parseCron(pattern);
+	const next = new Date(after);
+	next.setSeconds(0, 0);
+	let nextMs = next.getTime() + 60_000;
+
+	const limit = new Date(after);
+	limit.setFullYear(limit.getFullYear() + 4);
+	const limitMs = limit.getTime();
+
+	while (nextMs <= limitMs) {
+		if (cronMatchesParts(cron, getZonedCronDateParts(nextMs, timezone))) {
+			return nextMs;
+		}
+		nextMs += 60_000;
+	}
+
+	throw new Error(
+		`No cron occurrence found within 4 years for pattern "${pattern}" in timezone "${timezone}"`,
+	);
+}
+
+export function getNextCronTime(
+	pattern: string,
+	after: number,
+	timezone?: string,
+): number {
+	const normalizedTimezone = normalizeTimezone(timezone);
+	if (normalizedTimezone) {
+		validateTimezone(normalizedTimezone);
+		return getNextCronTimeByMinuteScan(pattern, after, normalizedTimezone);
+	}
+
+	const cron = parseCron(pattern);
+	let next = new Date(after);
+	next.setSeconds(0, 0);
+	next = new Date(next.getTime() + 60_000);
+
+	const limit = new Date(after);
+	limit.setFullYear(limit.getFullYear() + 4);
+
+	while (next <= limit) {
+		const { month, dayOfMonth, dayOfWeek, hour, minute } =
+			getLocalCronDateParts(next.getTime());
+
+		if (!cron.months.includes(month)) {
+			const targetMonth =
+				cron.months.find((value) => value > month) ??
+				getFirstCronValue(cron.months, "months");
+			const yearDelta = targetMonth <= month ? 1 : 0;
+			next = new Date(
+				next.getFullYear() + yearDelta,
+				targetMonth - 1,
+				1,
+				0,
+				0,
+				0,
+				0,
+			);
+			continue;
+		}
+
+		if (
+			!cron.daysOfMonth.includes(dayOfMonth) ||
+			!cron.daysOfWeek.includes(dayOfWeek)
+		) {
+			next = new Date(
+				next.getFullYear(),
+				next.getMonth(),
+				dayOfMonth + 1,
+				0,
+				0,
+				0,
+				0,
+			);
+			continue;
+		}
+
+		if (!cron.hours.includes(hour)) {
+			const targetHour =
+				cron.hours.find((value) => value > hour) ??
+				getFirstCronValue(cron.hours, "hours");
+			const dayDelta = targetHour <= hour ? 1 : 0;
+			next = new Date(
+				next.getFullYear(),
+				next.getMonth(),
+				next.getDate() + dayDelta,
+				targetHour,
+				0,
+				0,
+				0,
+			);
+			continue;
+		}
+
+		if (!cron.minutes.includes(minute)) {
+			const targetMinute =
+				cron.minutes.find((value) => value > minute) ??
+				getFirstCronValue(cron.minutes, "minutes");
+			const hourDelta = targetMinute <= minute ? 1 : 0;
+			next = new Date(
+				next.getFullYear(),
+				next.getMonth(),
+				next.getDate(),
+				next.getHours() + hourDelta,
+				targetMinute,
+				0,
+				0,
+			);
+			continue;
+		}
+
+		return next.getTime();
+	}
+
+	throw new Error(
+		`No cron occurrence found within 4 years for pattern "${pattern}"`,
+	);
+}

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

@@ -0,0 +1,163 @@
+import type { AutomationEventEnvelope, BasicLogger } from "@cline/shared";
+import type { ResolveCronSpecsDirOptions } from "@cline/shared/storage";
+import {
+	CronEventIngress,
+	type CronEventIngressResult,
+} from "../events/cron-event-ingress";
+import { CronMaterializer } from "../runner/cron-materializer";
+import { CronRunner } from "../runner/cron-runner";
+import { CronReconciler } from "../specs/cron-reconciler";
+import { CronWatcher } from "../specs/cron-watcher";
+import type {
+	CronRunRecord,
+	CronSpecRecord,
+	ListEventLogsOptions,
+	ListRunsOptions,
+	ListSpecsOptions,
+} from "../store/sqlite-cron-store";
+import { SqliteCronStore } from "../store/sqlite-cron-store";
+import type { HubScheduleRuntimeHandlers } from "./schedule-service";
+
+/**
+ * Top-level orchestrator for file-based cron automation.
+ *
+ * Wires together:
+ *   - `SqliteCronStore` (cron.db)
+ *   - `CronReconciler` (disk -> DB)
+ *   - `CronWatcher` (cron specs directory filesystem events)
+ *   - `CronMaterializer` (queue materialization)
+ *   - `CronRunner` (claim + execute + report)
+ *
+ * This service is the forward path: the legacy `HubScheduleService`
+ * continues to serve programmatic schedules, while `CronService` handles
+ * everything sourced from the configured file-based cron directory.
+ */
+
+export interface CronServiceOptions {
+	/** Default runtime workspace for the hub/daemon process. */
+	workspaceRoot: string;
+	/** Cron spec source/report location. Defaults to global `~/.cline/cron`. */
+	specs?: ResolveCronSpecsDirOptions;
+	runtimeHandlers: HubScheduleRuntimeHandlers;
+	dbPath?: string;
+	logger?: BasicLogger;
+	pollIntervalMs?: number;
+	claimLeaseSeconds?: number;
+	globalMaxConcurrency?: number;
+	watcherDebounceMs?: number;
+}
+
+export class CronService {
+	private readonly store: SqliteCronStore;
+	private readonly reconciler: CronReconciler;
+	private readonly watcher: CronWatcher;
+	private readonly eventIngress: CronEventIngress;
+	private readonly materializer: CronMaterializer;
+	private readonly runner: CronRunner;
+	private started = false;
+	private disposed = false;
+
+	constructor(options: CronServiceOptions) {
+		this.store = new SqliteCronStore({ dbPath: options.dbPath });
+		const specs = options.specs;
+		this.reconciler = new CronReconciler({
+			store: this.store,
+			specs,
+		});
+		this.materializer = new CronMaterializer({ store: this.store });
+		this.eventIngress = new CronEventIngress({
+			store: this.store,
+			logger: options.logger,
+		});
+		this.runner = new CronRunner({
+			store: this.store,
+			materializer: this.materializer,
+			runtimeHandlers: options.runtimeHandlers,
+			workspaceRoot: options.workspaceRoot,
+			specs,
+			logger: options.logger,
+			pollIntervalMs: options.pollIntervalMs,
+			claimLeaseSeconds: options.claimLeaseSeconds,
+			globalMaxConcurrency: options.globalMaxConcurrency,
+		});
+		this.watcher = new CronWatcher({
+			reconciler: this.reconciler,
+			debounceMs: options.watcherDebounceMs,
+			onReconciled: () => {
+				this.materializer.materializeAll();
+			},
+			onError: (err) => {
+				const log = options.logger;
+				if (log) {
+					if (log.error) log.error("cron.watcher.failed", { error: err });
+					else log.log("cron.watcher.failed", { error: err });
+				}
+			},
+		});
+	}
+
+	public async start(): Promise<void> {
+		if (this.disposed) throw new Error("CronService disposed");
+		if (this.started) return;
+		this.started = true;
+		await this.reconciler.reconcileAll();
+		this.materializer.materializeAll();
+		this.watcher.start();
+		await this.runner.start();
+	}
+
+	public async stop(): Promise<void> {
+		this.watcher.stop();
+		await this.runner.stop();
+		this.started = false;
+	}
+
+	public async dispose(): Promise<void> {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.watcher.dispose();
+		await this.runner.dispose();
+		this.store.close();
+	}
+
+	public listSpecs(options?: ListSpecsOptions): CronSpecRecord[] {
+		return this.store.listSpecs(options);
+	}
+
+	public getSpec(specId: string): CronSpecRecord | undefined {
+		return this.store.getSpec(specId);
+	}
+
+	public listRuns(options?: ListRunsOptions): CronRunRecord[] {
+		return this.store.listRuns(options);
+	}
+
+	public getRun(runId: string): CronRunRecord | undefined {
+		return this.store.getRun(runId);
+	}
+
+	public listActiveRuns(): CronRunRecord[] {
+		return this.store.listRuns({ status: "running", limit: 200 });
+	}
+
+	public listUpcomingRuns(limit = 20): CronRunRecord[] {
+		return this.store.listRuns({ status: "queued", limit });
+	}
+
+	public async reconcileNow(): Promise<void> {
+		await this.reconciler.reconcileAll();
+		this.materializer.materializeAll();
+	}
+
+	public ingestEvent(event: AutomationEventEnvelope): CronEventIngressResult {
+		return this.eventIngress.ingestEvent(event);
+	}
+
+	public listEventLogs(options?: ListEventLogsOptions) {
+		return this.store.listEventLogs(options);
+	}
+
+	public getEventLog(eventId: string) {
+		return this.store.getEventLog(eventId);
+	}
+}

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

@@ -0,0 +1,3 @@
+export * from "./cron-service";
+export * from "./schedule-command-service";
+export * from "./schedule-service";