codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/shared/src/storage/path-resolution.ts

@@ -0,0 +1,114 @@
+/**
+ * Path-resolution helpers that tolerate Unicode variants commonly seen on
+ * macOS filenames (most notably U+202F NARROW NO-BREAK SPACE in screenshot
+ * timestamps like "Screenshot 2026-05-12 at 4.42.48\u202FPM.png").
+ *
+ * When such a path travels through clipboards, terminals, paste-decoders,
+ * or other layers that normalize whitespace, U+202F can collapse to a
+ * regular space (U+0020). The on-disk filename still contains U+202F, so
+ * a literal `fs.stat` / `fs.readFile` will fail with ENOENT.
+ *
+ * `resolveExistingFilePath` tries a small set of targeted variants and a
+ * last-resort parent-directory scan to recover the actual filename.
+ */
+import { existsSync, readdirSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+
+// Unicode whitespace code points that show up in macOS-generated filenames
+// (or get substituted away by clipboards / terminals).
+const UNICODE_SPACES_RE = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+const NARROW_NO_BREAK_SPACE = "\u202F";
+
+// Build a "canonical whitespace" key for comparing a pasted/typed path
+// against actual on-disk entries regardless of which exotic space variant
+// was used between segments.
+function collapseUnicodeWhitespace(name: string): string {
+	return name.normalize("NFC").replace(UNICODE_SPACES_RE, " ");
+}
+
+function tryMacOSAmPmVariant(filePath: string): string {
+	// macOS Sonoma+ inserts U+202F before AM/PM in screenshot names. Some
+	// locales (e.g. en_AU) emit lowercase am/pm; hence the /i flag.
+	const fileName = basename(filePath);
+	const variantName = fileName.replace(
+		/ (AM|PM)\./gi,
+		`${NARROW_NO_BREAK_SPACE}$1.`,
+	);
+	return variantName === fileName
+		? filePath
+		: join(dirname(filePath), variantName);
+}
+
+function tryNFDVariant(filePath: string): string {
+	// HFS+ / some APFS configurations store filenames decomposed. Users
+	// typically type or paste NFC. Try the NFD variant when the literal
+	// path didn't resolve.
+	return filePath.normalize("NFD");
+}
+
+function tryCurlyApostropheVariant(filePath: string): string {
+	// macOS uses U+2019 (right single quotation mark) in localized
+	// screenshot names like "Capture d'écran". Users typically type U+0027.
+	return filePath.replace(/'/g, "\u2019");
+}
+
+function scanDirForCanonicalMatch(filePath: string): string | undefined {
+	// Last-resort fallback: enumerate the parent directory and look for an
+	// entry whose canonical-whitespace form matches the requested basename.
+	// Catches arbitrary exotic-space mismatches the targeted variants
+	// above don't cover.
+	const dir = dirname(filePath);
+	const wanted = collapseUnicodeWhitespace(basename(filePath));
+	try {
+		for (const entry of readdirSync(dir)) {
+			if (collapseUnicodeWhitespace(entry) === wanted) {
+				return join(dir, entry);
+			}
+		}
+	} catch {
+		// Directory unreadable or missing -- nothing to fall back to.
+	}
+	return undefined;
+}
+
+/**
+ * Resolve a possibly-mangled file path to an actual on-disk entry.
+ *
+ * Returns the literal path when it already exists; otherwise tries a small
+ * set of macOS-specific variants (narrow no-break space before AM/PM, NFD
+ * normalization, curly apostrophe) before falling back to a parent-directory
+ * scan that compares filenames after collapsing exotic Unicode whitespace.
+ *
+ * Returns `undefined` when no matching file can be located.
+ */
+export function resolveExistingFilePath(filePath: string): string | undefined {
+	if (existsSync(filePath)) {
+		return filePath;
+	}
+
+	const amPmVariant = tryMacOSAmPmVariant(filePath);
+	if (amPmVariant !== filePath && existsSync(amPmVariant)) {
+		return amPmVariant;
+	}
+
+	const nfdVariant = tryNFDVariant(filePath);
+	if (nfdVariant !== filePath && existsSync(nfdVariant)) {
+		return nfdVariant;
+	}
+
+	const curlyVariant = tryCurlyApostropheVariant(filePath);
+	if (curlyVariant !== filePath && existsSync(curlyVariant)) {
+		return curlyVariant;
+	}
+
+	const nfdCurlyVariant = tryCurlyApostropheVariant(nfdVariant);
+	if (
+		nfdCurlyVariant !== nfdVariant &&
+		nfdCurlyVariant !== curlyVariant &&
+		existsSync(nfdCurlyVariant)
+	) {
+		return nfdCurlyVariant;
+	}
+
+	return scanDirForCanonicalMatch(filePath);
+}

codna/agent-core/vendor/cline/sdk/packages/shared/src/storage/paths.home-dir.test.ts

@@ -0,0 +1,61 @@
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+type EnvSnapshot = {
+	HOME: string | undefined;
+	USERPROFILE: string | undefined;
+	HOMEDRIVE: string | undefined;
+	HOMEPATH: string | undefined;
+	CLINE_DIR: string | undefined;
+};
+
+function captureEnv(): EnvSnapshot {
+	return {
+		HOME: process.env.HOME,
+		USERPROFILE: process.env.USERPROFILE,
+		HOMEDRIVE: process.env.HOMEDRIVE,
+		HOMEPATH: process.env.HOMEPATH,
+		CLINE_DIR: process.env.CLINE_DIR,
+	};
+}
+
+function restoreEnv(snapshot: EnvSnapshot): void {
+	process.env.HOME = snapshot.HOME;
+	process.env.USERPROFILE = snapshot.USERPROFILE;
+	process.env.HOMEDRIVE = snapshot.HOMEDRIVE;
+	process.env.HOMEPATH = snapshot.HOMEPATH;
+	process.env.CLINE_DIR = snapshot.CLINE_DIR;
+}
+
+describe("storage home directory fallback", () => {
+	let snapshot: EnvSnapshot = captureEnv();
+
+	afterEach(() => {
+		restoreEnv(snapshot);
+		vi.resetModules();
+	});
+
+	it("uses USERPROFILE when HOME is unset", async () => {
+		snapshot = captureEnv();
+		delete process.env.HOME;
+		process.env.USERPROFILE = "C:\\Users\\saoud";
+		delete process.env.HOMEDRIVE;
+		delete process.env.HOMEPATH;
+		delete process.env.CLINE_DIR;
+
+		const { resolveClineDir } = await import("./paths");
+		expect(resolveClineDir()).toBe(join("C:\\Users\\saoud", ".cline"));
+	});
+
+	it("treats HOME=~ as unset and falls back to USERPROFILE", async () => {
+		snapshot = captureEnv();
+		process.env.HOME = "~";
+		process.env.USERPROFILE = "C:\\Users\\saoud";
+		delete process.env.HOMEDRIVE;
+		delete process.env.HOMEPATH;
+		delete process.env.CLINE_DIR;
+
+		const { resolveClineDir } = await import("./paths");
+		expect(resolveClineDir()).toBe(join("C:\\Users\\saoud", ".cline"));
+	});
+});

codna/agent-core/vendor/cline/sdk/packages/shared/src/storage/paths.test.ts

@@ -0,0 +1,180 @@
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	AGENT_CONFIG_DIRECTORY_NAME,
+	CLINE_MCP_SETTINGS_FILE_NAME,
+	HOOKS_CONFIG_DIRECTORY_NAME,
+	RULES_CONFIG_DIRECTORY_NAME,
+	resolveAgentsConfigDirPath,
+	resolveClineDataDir,
+	resolveDbDataDir,
+	resolveGlobalAgentsRulesPath,
+	resolveGlobalSettingsPath,
+	resolveHooksConfigSearchPaths,
+	resolveMcpSettingsPath,
+	resolveProviderSettingsPath,
+	resolveRulesConfigSearchPaths,
+	resolveSessionDataDir,
+	resolveTeamDataDir,
+	resolveWorkflowsConfigSearchPaths,
+} from "./paths";
+
+type EnvSnapshot = {
+	CLINE_DIR: string | undefined;
+	CLINE_DATA_DIR: string | undefined;
+	CLINE_DB_DATA_DIR: string | undefined;
+	CLINE_GLOBAL_SETTINGS_PATH: string | undefined;
+	CLINE_MCP_SETTINGS_PATH: string | undefined;
+	CLINE_PROVIDER_SETTINGS_PATH: string | undefined;
+	CLINE_SESSION_DATA_DIR: string | undefined;
+	CLINE_TEAM_DATA_DIR: string | undefined;
+};
+
+function captureEnv(): EnvSnapshot {
+	return {
+		CLINE_DIR: process.env.CLINE_DIR,
+		CLINE_DATA_DIR: process.env.CLINE_DATA_DIR,
+		CLINE_DB_DATA_DIR: process.env.CLINE_DB_DATA_DIR,
+		CLINE_GLOBAL_SETTINGS_PATH: process.env.CLINE_GLOBAL_SETTINGS_PATH,
+		CLINE_MCP_SETTINGS_PATH: process.env.CLINE_MCP_SETTINGS_PATH,
+		CLINE_PROVIDER_SETTINGS_PATH: process.env.CLINE_PROVIDER_SETTINGS_PATH,
+		CLINE_SESSION_DATA_DIR: process.env.CLINE_SESSION_DATA_DIR,
+		CLINE_TEAM_DATA_DIR: process.env.CLINE_TEAM_DATA_DIR,
+	};
+}
+
+function restoreEnv(snapshot: EnvSnapshot): void {
+	process.env.CLINE_DATA_DIR = snapshot.CLINE_DATA_DIR;
+	process.env.CLINE_DIR = snapshot.CLINE_DIR;
+	process.env.CLINE_DB_DATA_DIR = snapshot.CLINE_DB_DATA_DIR;
+	process.env.CLINE_GLOBAL_SETTINGS_PATH = snapshot.CLINE_GLOBAL_SETTINGS_PATH;
+	process.env.CLINE_MCP_SETTINGS_PATH = snapshot.CLINE_MCP_SETTINGS_PATH;
+	process.env.CLINE_PROVIDER_SETTINGS_PATH =
+		snapshot.CLINE_PROVIDER_SETTINGS_PATH;
+	process.env.CLINE_SESSION_DATA_DIR = snapshot.CLINE_SESSION_DATA_DIR;
+	process.env.CLINE_TEAM_DATA_DIR = snapshot.CLINE_TEAM_DATA_DIR;
+}
+
+describe("storage path resolution", () => {
+	let snapshot: EnvSnapshot = captureEnv();
+
+	afterEach(() => {
+		restoreEnv(snapshot);
+	});
+
+	it("uses CLINE_DATA_DIR as-is when set", () => {
+		snapshot = captureEnv();
+		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
+
+		expect(resolveClineDataDir()).toBe("/tmp/cline-data");
+	});
+
+	it("falls back to CLINE_DATA_DIR/sessions for session storage", () => {
+		snapshot = captureEnv();
+		delete process.env.CLINE_SESSION_DATA_DIR;
+		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
+
+		expect(resolveSessionDataDir()).toBe(join("/tmp/cline-data", "sessions"));
+	});
+
+	it("falls back to CLINE_DATA_DIR/teams for team storage", () => {
+		snapshot = captureEnv();
+		delete process.env.CLINE_TEAM_DATA_DIR;
+		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
+
+		expect(resolveTeamDataDir()).toBe(join("/tmp/cline-data", "teams"));
+	});
+
+	it("falls back to CLINE_DATA_DIR/db for sqlite storage", () => {
+		snapshot = captureEnv();
+		delete process.env.CLINE_DB_DATA_DIR;
+		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
+
+		expect(resolveDbDataDir()).toBe(join("/tmp/cline-data", "db"));
+	});
+
+	it("falls back to CLINE_DATA_DIR/settings/providers.json for provider settings", () => {
+		snapshot = captureEnv();
+		delete process.env.CLINE_PROVIDER_SETTINGS_PATH;
+		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
+
+		expect(resolveProviderSettingsPath()).toBe(
+			join("/tmp/cline-data", "settings", "providers.json"),
+		);
+	});
+
+	it("falls back to CLINE_DATA_DIR/settings/global-settings.json for global settings", () => {
+		snapshot = captureEnv();
+		delete process.env.CLINE_GLOBAL_SETTINGS_PATH;
+		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
+
+		expect(resolveGlobalSettingsPath()).toBe(
+			join("/tmp/cline-data", "settings", "global-settings.json"),
+		);
+	});
+
+	it("falls back to CLINE_DATA_DIR/settings/cline_mcp_settings.json for MCP settings", () => {
+		snapshot = captureEnv();
+		delete process.env.CLINE_MCP_SETTINGS_PATH;
+		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
+
+		expect(resolveMcpSettingsPath()).toBe(
+			join("/tmp/cline-data", "settings", CLINE_MCP_SETTINGS_FILE_NAME),
+		);
+	});
+
+	it("falls back to ~/.cline/.agents for agent configs", () => {
+		snapshot = captureEnv();
+		process.env.CLINE_DIR = "/tmp/home/.cline";
+
+		expect(resolveAgentsConfigDirPath()).toBe(
+			join("/tmp/home", ".cline", AGENT_CONFIG_DIRECTORY_NAME),
+		);
+	});
+
+	it("resolves global hooks from ~/.cline", () => {
+		snapshot = captureEnv();
+		process.env.CLINE_DIR = "/tmp/home/.cline";
+		process.env.CLINE_DATA_DIR = "/tmp/home/.cline/data";
+
+		expect(resolveHooksConfigSearchPaths()).toEqual(
+			expect.arrayContaining([
+				join("/tmp/home", ".cline", HOOKS_CONFIG_DIRECTORY_NAME),
+			]),
+		);
+		expect(resolveHooksConfigSearchPaths()).not.toContain(
+			join("/tmp/home", ".cline", "data", HOOKS_CONFIG_DIRECTORY_NAME),
+		);
+	});
+
+	it("resolves global rules from ~/.cline", () => {
+		snapshot = captureEnv();
+		process.env.CLINE_DIR = "/tmp/home/.cline";
+		process.env.CLINE_DATA_DIR = "/tmp/home/.cline/data";
+
+		expect(resolveRulesConfigSearchPaths()).toEqual(
+			expect.arrayContaining([
+				resolveGlobalAgentsRulesPath(),
+				join("/tmp/home", ".cline", RULES_CONFIG_DIRECTORY_NAME),
+			]),
+		);
+		expect(resolveRulesConfigSearchPaths()).not.toContain(
+			join("/tmp/home", ".cline", "data", RULES_CONFIG_DIRECTORY_NAME),
+		);
+	});
+
+	it("resolves legacy and new workflow paths, with .cline paths later for duplicate-name precedence", () => {
+		snapshot = captureEnv();
+		process.env.CLINE_DIR = "/tmp/home/.cline";
+		const workspacePath = "/repo/demo";
+
+		const paths = resolveWorkflowsConfigSearchPaths(workspacePath);
+
+		expect(paths).toEqual([
+			join(workspacePath, ".clinerules", "workflows"),
+			expect.stringContaining(join("Documents", "Cline", "Workflows")),
+			join("/tmp/home", ".cline", "workflows"),
+			join(workspacePath, ".cline", "workflows"),
+		]);
+	});
+});