codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/examples/hooks/PostToolUse.ts

@@ -0,0 +1,86 @@
+#!/usr/bin/env bun
+/**
+ * Cline Hook: PostToolUse (TypeScript)
+ * Logs tool results with structured output.
+ * Copy to ~/.cline/hooks/PostToolUse.ts and chmod +x
+ */
+
+interface ToolResult {
+	id: string;
+	name: string;
+	input: Record<string, unknown>;
+	output: unknown;
+	error: unknown;
+	durationMs: number;
+}
+
+interface HookEvent {
+	hookName: string;
+	tool_result: ToolResult;
+	postToolUse: {
+		toolName: string;
+		parameters: Record<string, unknown>;
+		result: string;
+		success: boolean;
+		executionTimeMs: number;
+	};
+}
+
+interface HookControl {
+	context?: string;
+	errorMessage?: string;
+}
+
+async function getGitBranch(): Promise<string | null> {
+	try {
+		const proc = Bun.spawn(["git", "branch", "--show-current"]);
+		const output = await new Response(proc.stdout).text();
+		return output.trim() || null;
+	} catch {
+		return null;
+	}
+}
+
+async function main(): Promise<void> {
+	let event: HookEvent;
+
+	try {
+		const input = await Bun.stdin.text();
+		event = JSON.parse(input) as HookEvent;
+	} catch (error) {
+		const message =
+			error instanceof Error ? error.message : "Unknown parse error";
+		console.log(
+			JSON.stringify({ errorMessage: `Failed to parse: ${message}` }),
+		);
+		return;
+	}
+
+	const toolName = event.tool_result.name;
+	const success = event.postToolUse.success;
+	const durationMs = event.postToolUse.executionTimeMs;
+
+	// Log result
+	const status = success ? "✅" : "❌";
+	console.error(`${status} Tool: ${toolName} (${durationMs}ms)`);
+
+	// For run_commands, inject environment context
+	if (toolName === "run_commands") {
+		const branch = await getGitBranch();
+		if (branch) {
+			const control: HookControl = {
+				context: `Environment: git branch: ${branch}`,
+			};
+			console.log(JSON.stringify(control));
+			return;
+		}
+	}
+
+	// Return empty control
+	console.log(JSON.stringify({}));
+}
+
+main().catch((error) => {
+	console.error("Hook error:", error);
+	process.exit(1);
+});

codna/agent-core/vendor/cline/sdk/examples/hooks/PreToolUse.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""
+Cline Hook: PreToolUse (Python)
+Logs every tool call before it executes.
+Copy to ~/.cline/hooks/PreToolUse.py and chmod +x
+"""
+
+import sys
+import json
+
+def main():
+    # Read event payload from stdin
+    try:
+        event = json.load(sys.stdin)
+    except json.JSONDecodeError as e:
+        print(json.dumps({"errorMessage": f"Failed to parse hook input: {e}"}))
+        return
+
+    # Extract tool information
+    tool_call = event.get("tool_call", {})
+    tool_name = tool_call.get("name", "unknown")
+    parameters = event.get("preToolUse", {}).get("parameters", {})
+
+    # Log to stderr
+    print(f"🔧 Tool: {tool_name}", file=sys.stderr)
+    if parameters:
+        param_str = ", ".join(f"{k}={v}" for k, v in parameters.items())
+        print(f"   Args: {param_str}", file=sys.stderr)
+
+    # Return empty control object (allow the tool to execute)
+    print(json.dumps({}))
+
+if __name__ == "__main__":
+    main()

codna/agent-core/vendor/cline/sdk/examples/hooks/PreToolUse.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+# Cline Hook: PreToolUse
+# Logs every tool call before it executes
+# Copy to ~/.cline/hooks/PreToolUse.sh and chmod +x
+
+input=$(cat)
+tool=$(echo "$input" | jq -r '.tool_call.name // "unknown"')
+args=$(echo "$input" | jq -r '.preToolUse.parameters | to_entries | map("\(.key)=\(.value)") | join(", ")' 2>/dev/null || echo "")
+
+echo "🔧 Tool: $tool" >&2
+if [ -n "$args" ] && [ "$args" != "null" ]; then
+  echo "   Args: $args" >&2
+fi
+
+# Return empty object to allow the call to proceed
+echo '{}'

codna/agent-core/vendor/cline/sdk/examples/hooks/PreToolUse.ts

@@ -0,0 +1,66 @@
+#!/usr/bin/env bun
+/**
+ * Cline Hook: PreToolUse (TypeScript)
+ * Logs and filters tool calls with type safety.
+ * Copy to ~/.cline/hooks/PreToolUse.ts and chmod +x
+ */
+
+interface ToolCall {
+	id: string;
+	name: string;
+	input: Record<string, unknown>;
+}
+
+interface HookEvent {
+	hookName: string;
+	tool_call: ToolCall;
+	preToolUse: {
+		toolName: string;
+		parameters: Record<string, unknown>;
+	};
+}
+
+interface HookControl {
+	cancel?: boolean;
+	review?: boolean;
+	context?: string;
+	errorMessage?: string;
+	overrideInput?: unknown;
+}
+
+async function main(): Promise<void> {
+	let event: HookEvent;
+
+	try {
+		const input = await Bun.stdin.text();
+		event = JSON.parse(input) as HookEvent;
+	} catch (error) {
+		const message =
+			error instanceof Error ? error.message : "Unknown parse error";
+		console.log(
+			JSON.stringify({ errorMessage: `Failed to parse: ${message}` }),
+		);
+		return;
+	}
+
+	const toolName = event.tool_call.name;
+	const parameters = event.preToolUse.parameters;
+
+	// Log to stderr
+	console.error(`🔧 Tool: ${toolName}`);
+	if (Object.keys(parameters).length > 0) {
+		const paramStr = Object.entries(parameters)
+			.map(([k, v]) => `${k}=${v}`)
+			.join(", ");
+		console.error(`   Args: ${paramStr}`);
+	}
+
+	// Return empty control (allow execution)
+	const control: HookControl = {};
+	console.log(JSON.stringify(control));
+}
+
+main().catch((error) => {
+	console.error("Hook error:", error);
+	process.exit(1);
+});

codna/agent-core/vendor/cline/sdk/examples/hooks/PreToolUse_BlockDestructive.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+# Cline Hook: PreToolUse (Block Destructive)
+# Blocks dangerous operations
+# Copy to ~/.cline/hooks/PreToolUse.sh and chmod +x
+
+input=$(cat)
+tool=$(echo "$input" | jq -r '.tool_call.name // ""')
+cmd=$(echo "$input" | jq -r '.tool_call.input.command // ""')
+
+# Block dangerous git commands
+if [ "$tool" = "run_commands" ]; then
+  if [[ $cmd =~ (git\ reset\ --hard|git\ push\ --force|git\ push\ -f) ]]; then
+    jq -n --arg cmd "$cmd" '{cancel: true, errorMessage: "Destructive git command blocked: \($cmd). Use with explicit approval."}'
+    exit 0
+  fi
+
+  # Block bulk deletes
+  if [[ $cmd =~ (rm\ -rf|rm\ -r.*\*) ]]; then
+    jq -n --arg cmd "$cmd" '{cancel: true, errorMessage: "Bulk delete blocked: \($cmd). This is too risky."}'
+    exit 0
+  fi
+fi
+
+# Allow everything else
+echo '{}'

codna/agent-core/vendor/cline/sdk/examples/hooks/PreToolUse_InjectContext.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""
+Cline Hook: PreToolUse (Inject Context)
+Injects file context and environment info before tool execution.
+Copy to ~/.cline/hooks/PreToolUse.py and chmod +x
+"""
+
+import sys
+import json
+import os
+import subprocess
+from pathlib import Path
+
+def get_git_branch() -> str | None:
+    """Get current git branch."""
+    try:
+        result = subprocess.run(
+            ["git", "branch", "--show-current"],
+            capture_output=True,
+            text=True,
+            timeout=2
+        )
+        branch = result.stdout.strip()
+        return branch if branch else None
+    except Exception:
+        return None
+
+def get_node_version() -> str | None:
+    """Get Node.js version."""
+    try:
+        result = subprocess.run(
+            ["node", "--version"],
+            capture_output=True,
+            text=True,
+            timeout=2
+        )
+        return result.stdout.strip() if result.returncode == 0 else None
+    except Exception:
+        return None
+
+def get_file_context(file_path: str) -> str | None:
+    """Get context about related files."""
+    path = Path(file_path)
+
+    # For TypeScript files, check for test files
+    if path.suffix in [".ts", ".tsx"]:
+        test_file = path.with_stem(path.stem).with_suffix(".test.ts")
+        if test_file.exists():
+            return f"Associated test file exists: {test_file}"
+
+    # For package.json, mention lock files
+    if path.name == "package.json":
+        lock_files = []
+        for lock in ["package-lock.json", "yarn.lock", "pnpm-lock.yaml"]:
+            if (path.parent / lock).exists():
+                lock_files.append(lock)
+
+        if lock_files:
+            return f"Related lock files: {', '.join(lock_files)}"
+
+    # For config files, mention related configs
+    if path.name.endswith(".config.ts") or path.name.endswith(".config.js"):
+        basename = path.stem.replace(".config", "")
+        parent = path.parent
+        related = []
+        for ext in [".ts", ".js", ".json"]:
+            env_file = parent / f"{basename}.env{ext}"
+            if env_file.exists():
+                related.append(f"{env_file.name}")
+        if related:
+            return f"Related config files: {', '.join(related)}"
+
+    return None
+
+def main():
+    try:
+        event = json.load(sys.stdin)
+    except json.JSONDecodeError as e:
+        print(json.dumps({"errorMessage": f"Failed to parse: {e}"}))
+        return
+
+    tool_call = event.get("tool_call", {})
+    tool_name = tool_call.get("name", "")
+    tool_input = tool_call.get("input", {})
+
+    # Inject file context when reading files
+    if tool_name == "read_files":
+        file_path = tool_input.get("filePath", "")
+        if file_path:
+            context = get_file_context(file_path)
+            if context:
+                print(json.dumps({"context": context}))
+                return
+
+    # Inject environment context for run_commands
+    if tool_name == "run_commands":
+        context_parts = []
+
+        node_version = get_node_version()
+        if node_version:
+            context_parts.append(f"node {node_version}")
+
+        git_branch = get_git_branch()
+        if git_branch:
+            context_parts.append(f"git branch: {git_branch}")
+
+        if context_parts:
+            context = "Environment: " + ", ".join(context_parts)
+            print(json.dumps({"context": context}))
+            return
+
+    # Allow other tools without modification
+    print(json.dumps({}))
+
+if __name__ == "__main__":
+    main()

codna/agent-core/vendor/cline/sdk/examples/hooks/PreToolUse_InjectFileContext.sh

@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+# Cline Hook: PreToolUse (Inject File Context)
+# Extracts and injects file context before tool execution
+# Copy to ~/.cline/hooks/PreToolUse.sh and chmod +x
+
+input=$(cat)
+tool=$(echo "$input" | jq -r '.tool_call.name // ""')
+filePath=$(echo "$input" | jq -r '.tool_call.input.filePath // ""')
+
+# When reading a file, check for related files to provide context
+if [ "$tool" = "read_files" ] && [ -n "$filePath" ]; then
+  # Extract directory and filename
+  dir=$(dirname "$filePath")
+  name=$(basename "$filePath")
+
+  # Check for related files (e.g., if reading .ts, mention .test.ts)
+  context_files=""
+
+  # For TypeScript files, check for test files
+  if [[ $filePath == *.ts || $filePath == *.tsx ]]; then
+    test_file="${filePath%.ts*}.test.ts"
+    if [ -f "$test_file" ]; then
+      context_files="Associated test file exists: $test_file"
+    fi
+  fi
+
+  # For package.json, suggest related files
+  if [ "$name" = "package.json" ]; then
+    related=""
+    [ -f "$dir/package-lock.json" ] && related="$related package-lock.json"
+    [ -f "$dir/yarn.lock" ] && related="$related yarn.lock"
+    [ -f "$dir/pnpm-lock.yaml" ] && related="$related pnpm-lock.yaml"
+    if [ -n "$related" ]; then
+      context_files="Related lock files:$related"
+    fi
+  fi
+
+  if [ -n "$context_files" ]; then
+    jq -n --arg ctx "$context_files" '{context: $ctx}'
+    exit 0
+  fi
+fi
+
+# For run_commands, inject environment info
+if [ "$tool" = "run_commands" ]; then
+  node_version=$(node --version 2>/dev/null || echo "not installed")
+  git_branch=$(git branch --show-current 2>/dev/null || echo "")
+
+  context="Environment: node $node_version"
+  [ -n "$git_branch" ] && context="$context, branch: $git_branch"
+
+  jq -n --arg ctx "$context" '{context: $ctx}'
+  exit 0
+fi
+
+# Allow other tools to proceed without modification
+echo '{}'

codna/agent-core/vendor/cline/sdk/examples/hooks/PreToolUse_ModifyInput.ts

@@ -0,0 +1,125 @@
+#!/usr/bin/env bun
+/**
+ * Cline Hook: PreToolUse (Modify Input)
+ * Demonstrates how to modify tool inputs before execution.
+ * Useful for: normalizing paths, adding default options, sanitizing inputs.
+ * Copy to ~/.cline/hooks/PreToolUse.ts and chmod +x
+ */
+
+interface ToolInput {
+	[key: string]: unknown;
+}
+
+interface ToolCall {
+	id: string;
+	name: string;
+	input: ToolInput;
+}
+
+interface HookEvent {
+	hookName: string;
+	tool_call: ToolCall;
+	preToolUse: {
+		toolName: string;
+		parameters: Record<string, unknown>;
+	};
+}
+
+interface HookControl {
+	context?: string;
+	overrideInput?: Record<string, unknown>;
+}
+
+function normalizeFilePath(path: string): string {
+	// Convert backslashes to forward slashes (Windows paths)
+	let normalized = path.replace(/\\/g, "/");
+
+	// Resolve ~/ to home directory
+	const home = process.env.HOME || process.env.USERPROFILE;
+	if (normalized.startsWith("~/") && home) {
+		normalized = normalized.replace(/^~/, home);
+	}
+
+	return normalized;
+}
+
+async function main(): Promise<void> {
+	let event: HookEvent;
+
+	try {
+		const input = await Bun.stdin.text();
+		event = JSON.parse(input) as HookEvent;
+	} catch (error) {
+		const message =
+			error instanceof Error ? error.message : "Unknown parse error";
+		console.log(
+			JSON.stringify({ errorMessage: `Failed to parse: ${message}` }),
+		);
+		return;
+	}
+
+	const toolCall = event.tool_call;
+	const toolName = toolCall.name;
+	const toolInput = toolCall.input as Record<string, unknown>;
+
+	// Modify read_files input: normalize paths
+	if (toolName === "read_files" && typeof toolInput.filePath === "string") {
+		const normalized = normalizeFilePath(toolInput.filePath);
+		if (normalized !== toolInput.filePath) {
+			const control: HookControl = {
+				context: `Normalized file path from "${toolInput.filePath}" to "${normalized}"`,
+				overrideInput: {
+					...toolInput,
+					filePath: normalized,
+				},
+			};
+			console.log(JSON.stringify(control));
+			return;
+		}
+	}
+
+	// Modify editor input: add safety defaults
+	if (toolName === "editor" && typeof toolInput.filePath === "string") {
+		// For critical files, add a reminder
+		const filePath = toolInput.filePath as string;
+		if (
+			filePath.includes("package.json") ||
+			filePath.includes(".env") ||
+			filePath.includes("tsconfig")
+		) {
+			const control: HookControl = {
+				context:
+					"WARNING: You are about to modify a critical configuration file. Verify changes carefully.",
+			};
+			console.log(JSON.stringify(control));
+			return;
+		}
+	}
+
+	// Modify run_commands input: add safety flags
+	if (toolName === "run_commands" && typeof toolInput.command === "string") {
+		const cmd = toolInput.command as string;
+
+		// Add safety flags to npm/yarn installs
+		if (cmd.includes("npm install") && !cmd.includes("--save")) {
+			const newCmd = cmd.replace("npm install", "npm install --save-exact");
+			const control: HookControl = {
+				context: "Added --save-exact flag for reproducible installs",
+				overrideInput: {
+					...toolInput,
+					command: newCmd,
+				},
+			};
+			console.log(JSON.stringify(control));
+			return;
+		}
+	}
+
+	// No modifications needed
+	console.log(JSON.stringify({}));
+}
+
+main().catch((error) => {
+	console.error("Hook error:", error);
+	process.exit(1);
+});

codna/agent-core/vendor/cline/sdk/examples/hooks/PreToolUse_RequireReview.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# Cline Hook: PreToolUse (Require Review)
+# Pauses for review before writing to critical files
+# Copy to ~/.cline/hooks/PreToolUse.sh and chmod +x
+
+input=$(cat)
+tool=$(echo "$input" | jq -r '.tool_call.name // ""')
+file=$(echo "$input" | jq -r '.tool_call.input.filePath // ""')
+
+# Require review for critical files
+if [ "$tool" = "editor" ] || [ "$tool" = "write_file" ]; then
+  if [[ $file =~ (package\.json|tsconfig|\.env|secrets|config\.(ts|js)|\.cline) ]]; then
+    jq -n --arg file "$file" '{review: true, context: "This will modify a critical file: \($file)"}'
+    exit 0
+  fi
+fi
+
+# Allow everything else
+echo '{}'