opencodekit 0.14.6 → 0.15.0

package/dist/template/.opencode/skill/writing-skills/persuasion-principles.md

@@ -9,142 +9,171 @@ LLMs respond to the same persuasion principles as humans. Understanding this psy
 ## The Seven Principles
 
 ### 1. Authority
+
 **What it is:** Deference to expertise, credentials, or official sources.
 
 **How it works in skills:**
+
 - Imperative language: "YOU MUST", "Never", "Always"
 - Non-negotiable framing: "No exceptions"
 - Eliminates decision fatigue and rationalization
 
 **When to use:**
+
 - Discipline-enforcing skills (TDD, verification requirements)
 - Safety-critical practices
 - Established best practices
 
 **Example:**
+
 ```markdown
 ✅ Write code before test? Delete it. Start over. No exceptions.
 ❌ Consider writing tests first when feasible.
 ```
 
 ### 2. Commitment
+
 **What it is:** Consistency with prior actions, statements, or public declarations.
 
 **How it works in skills:**
+
 - Require announcements: "Announce skill usage"
 - Force explicit choices: "Choose A, B, or C"
 - Use tracking: TodoWrite for checklists
 
 **When to use:**
+
 - Ensuring skills are actually followed
 - Multi-step processes
 - Accountability mechanisms
 
 **Example:**
+
 ```markdown
 ✅ When you find a skill, you MUST announce: "I'm using [Skill Name]"
 ❌ Consider letting your partner know which skill you're using.
 ```
 
 ### 3. Scarcity
+
 **What it is:** Urgency from time limits or limited availability.
 
 **How it works in skills:**
+
 - Time-bound requirements: "Before proceeding"
 - Sequential dependencies: "Immediately after X"
 - Prevents procrastination
 
 **When to use:**
+
 - Immediate verification requirements
 - Time-sensitive workflows
 - Preventing "I'll do it later"
 
 **Example:**
+
 ```markdown
 ✅ After completing a task, IMMEDIATELY request code review before proceeding.
 ❌ You can review code when convenient.
 ```
 
 ### 4. Social Proof
+
 **What it is:** Conformity to what others do or what's considered normal.
 
 **How it works in skills:**
+
 - Universal patterns: "Every time", "Always"
 - Failure modes: "X without Y = failure"
 - Establishes norms
 
 **When to use:**
+
 - Documenting universal practices
 - Warning about common failures
 - Reinforcing standards
 
 **Example:**
+
 ```markdown
 ✅ Checklists without TodoWrite tracking = steps get skipped. Every time.
 ❌ Some people find TodoWrite helpful for checklists.
 ```
 
 ### 5. Unity
+
 **What it is:** Shared identity, "we-ness", in-group belonging.
 
 **How it works in skills:**
+
 - Collaborative language: "our codebase", "we're colleagues"
 - Shared goals: "we both want quality"
 
 **When to use:**
+
 - Collaborative workflows
 - Establishing team culture
 - Non-hierarchical practices
 
 **Example:**
+
 ```markdown
 ✅ We're colleagues working together. I need your honest technical judgment.
 ❌ You should probably tell me if I'm wrong.
 ```
 
 ### 6. Reciprocity
+
 **What it is:** Obligation to return benefits received.
 
 **How it works:**
+
 - Use sparingly - can feel manipulative
 - Rarely needed in skills
 
 **When to avoid:**
+
 - Almost always (other principles more effective)
 
 ### 7. Liking
+
 **What it is:** Preference for cooperating with those we like.
 
 **How it works:**
+
 - **DON'T USE for compliance**
 - Conflicts with honest feedback culture
 - Creates sycophancy
 
 **When to avoid:**
+
 - Always for discipline enforcement
 
 ## Principle Combinations by Skill Type
 
-| Skill Type | Use | Avoid |
-|------------|-----|-------|
+| Skill Type           | Use                                   | Avoid               |
+| -------------------- | ------------------------------------- | ------------------- |
 | Discipline-enforcing | Authority + Commitment + Social Proof | Liking, Reciprocity |
-| Guidance/technique | Moderate Authority + Unity | Heavy authority |
-| Collaborative | Unity + Commitment | Authority, Liking |
-| Reference | Clarity only | All persuasion |
+| Guidance/technique   | Moderate Authority + Unity            | Heavy authority     |
+| Collaborative        | Unity + Commitment                    | Authority, Liking   |
+| Reference            | Clarity only                          | All persuasion      |
 
 ## Why This Works: The Psychology
 
 **Bright-line rules reduce rationalization:**
+
 - "YOU MUST" removes decision fatigue
 - Absolute language eliminates "is this an exception?" questions
 - Explicit anti-rationalization counters close specific loopholes
 
 **Implementation intentions create automatic behavior:**
+
 - Clear triggers + required actions = automatic execution
 - "When X, do Y" more effective than "generally do Y"
 - Reduces cognitive load on compliance
 
 **LLMs are parahuman:**
+
 - Trained on human text containing these patterns
 - Authority language precedes compliance in training data
 - Commitment sequences (statement → action) frequently modeled
@@ -153,11 +182,13 @@ LLMs respond to the same persuasion principles as humans. Understanding this psy
 ## Ethical Use
 
 **Legitimate:**
+
 - Ensuring critical practices are followed
 - Creating effective documentation
 - Preventing predictable failures
 
 **Illegitimate:**
+
 - Manipulating for personal gain
 - Creating false urgency
 - Guilt-based compliance
@@ -166,11 +197,13 @@ LLMs respond to the same persuasion principles as humans. Understanding this psy
 
 ## Research Citations
 
-**Cialdini, R. B. (2021).** *Influence: The Psychology of Persuasion (New and Expanded).* Harper Business.
+**Cialdini, R. B. (2021).** _Influence: The Psychology of Persuasion (New and Expanded)._ Harper Business.
+
 - Seven principles of persuasion
 - Empirical foundation for influence research
 
 **Meincke, L., Shapiro, D., Duckworth, A. L., Mollick, E., Mollick, L., & Cialdini, R. (2025).** Call Me A Jerk: Persuading AI to Comply with Objectionable Requests. University of Pennsylvania.
+
 - Tested 7 principles with N=28,000 LLM conversations
 - Compliance increased 33% → 72% with persuasion techniques
 - Authority, commitment, scarcity most effective

package/dist/template/.opencode/tool/memory-read.ts

@@ -3,64 +3,52 @@ import path from "node:path";
 import { tool } from "@opencode-ai/plugin";
 
 export default tool({
-	description:
-		"Read memory files for persistent cross-session context. Returns current project state, learnings, and active tasks. Supports subdirectories (e.g., 'research/opencode-sessions').",
-	args: {
-		file: tool.schema
-			.string()
-			.optional()
-			.describe(
-				"Memory file to read: handoffs/YYYY-MM-DD-phase, research/YYYY-MM-DD-topic, _templates/task-prd, _templates/task-spec, _templates/task-review, _templates/research, _templates/handoff",
-			),
-	},
-	execute: async (args: { file?: string }) => {
-		const fileName = args.file || "memory";
+  description:
+    "Read memory files for persistent cross-session context. Returns current project state, learnings, and active tasks. Supports subdirectories (e.g., 'research/opencode-sessions').",
+  args: {
+    file: tool.schema
+      .string()
+      .optional()
+      .describe(
+        "Memory file to read: handoffs/YYYY-MM-DD-phase, research/YYYY-MM-DD-topic, _templates/task-prd, _templates/task-spec, _templates/task-review, _templates/research, _templates/handoff",
+      ),
+  },
+  execute: async (args: { file?: string }) => {
+    const fileName = args.file || "memory";
 
-		// Normalize: strip .md extension if present
-		const normalizedFile = fileName.replace(/\.md$/i, "");
+    // Normalize: strip .md extension if present
+    const normalizedFile = fileName.replace(/\.md$/i, "");
 
-		// Location priority: project > global > legacy
-		const locations = [
-			path.join(process.cwd(), ".opencode/memory", `${normalizedFile}.md`),
-			path.join(
-				process.env.HOME || "",
-				".config/opencode/memory",
-				`${normalizedFile}.md`,
-			),
-			path.join(
-				process.cwd(),
-				".config/opencode/memory",
-				`${normalizedFile}.md`,
-			),
-		];
+    // Location priority: project > global > legacy
+    const locations = [
+      path.join(process.cwd(), ".opencode/memory", `${normalizedFile}.md`),
+      path.join(process.env.HOME || "", ".config/opencode/memory", `${normalizedFile}.md`),
+      path.join(process.cwd(), ".config/opencode/memory", `${normalizedFile}.md`),
+    ];
 
-		// Try each location in order
-		for (const filePath of locations) {
-			try {
-				const content = await fs.readFile(filePath, "utf-8");
-				const locationLabel = filePath.includes(".opencode/memory")
-					? "project"
-					: filePath.includes(process.env.HOME || "")
-						? "global"
-						: "legacy";
-				return `[Read from ${locationLabel}: ${filePath}]\n\n${content}`;
-			} catch (error) {
-				// Continue to next location if file not found
-				if (
-					error instanceof Error &&
-					"code" in error &&
-					error.code === "ENOENT"
-				) {
-					continue;
-				}
-				// Other errors should be reported
-				if (error instanceof Error) {
-					return `Error reading memory from ${filePath}: ${error.message}`;
-				}
-			}
-		}
+    // Try each location in order
+    for (const filePath of locations) {
+      try {
+        const content = await fs.readFile(filePath, "utf-8");
+        const locationLabel = filePath.includes(".opencode/memory")
+          ? "project"
+          : filePath.includes(process.env.HOME || "")
+            ? "global"
+            : "legacy";
+        return `[Read from ${locationLabel}: ${filePath}]\n\n${content}`;
+      } catch (error) {
+        // Continue to next location if file not found
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+          continue;
+        }
+        // Other errors should be reported
+        if (error instanceof Error) {
+          return `Error reading memory from ${filePath}: ${error.message}`;
+        }
+      }
+    }
 
-		// No file found in any location
-		return `Memory file '${normalizedFile}.md' not found in any location.\nSearched:\n- ${locations.join("\n- ")}\n\nStructure:\n- handoffs/YYYY-MM-DD-phase (phase transitions)\n- research/YYYY-MM-DD-topic (research findings)\n- _templates/ (prd, spec, review, research, handoff)`;
-	},
+    // No file found in any location
+    return `Memory file '${normalizedFile}.md' not found in any location.\nSearched:\n- ${locations.join("\n- ")}\n\nStructure:\n- handoffs/YYYY-MM-DD-phase (phase transitions)\n- research/YYYY-MM-DD-topic (research findings)\n- _templates/ (prd, spec, review, research, handoff)`;
+  },
 });

package/dist/template/.opencode/tool/memory-search.ts

@@ -1,82 +1,10 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { tool } from "@opencode-ai/plugin";
-import { searchVectorStore } from "./memory-index";
 
 interface SearchResult {
 	file: string;
 	matches: { line: number; content: string }[];
-	score?: number;
-}
-
-interface SemanticResult {
-	file: string;
-	title: string;
-	preview: string;
-	type: string;
-	score?: number;
-	confidence?: string;
-	age_days?: number;
-}
-
-// Confidence decay factor based on age (Graphiti-inspired)
-// Older observations with lower confidence rank lower
-function applyConfidenceDecay(
-	results: SemanticResult[],
-	contents: Map<string, string>,
-): SemanticResult[] {
-	const now = Date.now();
-
-	return results.map((result) => {
-		const content = contents.get(result.file) || "";
-
-		// Extract metadata from YAML frontmatter
-		const createdMatch = content.match(/created:\s*(.+)/);
-		const confidenceMatch = content.match(/confidence:\s*(\w+)/);
-		const validUntilMatch = content.match(/valid_until:\s*(.+)/);
-		const supersededByMatch = content.match(/superseded_by:\s*(.+)/);
-
-		// Check if superseded (should rank very low)
-		if (supersededByMatch && supersededByMatch[1] !== "null") {
-			return { ...result, score: (result.score || 1) * 0.1 };
-		}
-
-		// Check if expired
-		if (validUntilMatch && validUntilMatch[1] !== "null") {
-			const validUntil = new Date(validUntilMatch[1]).getTime();
-			if (validUntil < now) {
-				return { ...result, score: (result.score || 1) * 0.2 };
-			}
-		}
-
-		// Calculate age in days
-		let ageDays = 0;
-		if (createdMatch) {
-			const created = new Date(createdMatch[1]).getTime();
-			ageDays = Math.floor((now - created) / (1000 * 60 * 60 * 24));
-		}
-
-		// Confidence multiplier
-		const confidenceMultiplier: Record<string, number> = {
-			high: 1.0,
-			medium: 0.8,
-			low: 0.6,
-		};
-		const confidence = confidenceMatch?.[1] || "high";
-		const confMult = confidenceMultiplier[confidence] || 1.0;
-
-		// Age decay: lose 5% per 30 days, minimum 50%
-		const ageDecay = Math.max(0.5, 1 - (ageDays / 30) * 0.05);
-
-		const finalScore = (result.score || 1) * confMult * ageDecay;
-
-		return {
-			...result,
-			score: finalScore,
-			confidence,
-			age_days: ageDays,
-		};
-	});
 }
 
 async function searchDirectory(
@@ -125,7 +53,7 @@ async function searchDirectory(
 async function keywordSearch(
 	query: string,
 	type: string | undefined,
-	limit: number,
+	_limit: number,
 ): Promise<SearchResult[]> {
 	const memoryDir = path.join(process.cwd(), ".opencode/memory");
 	const beadsDir = path.join(process.cwd(), ".beads/artifacts");
@@ -171,58 +99,16 @@ async function keywordSearch(
 	return results;
 }
 
-async function semanticSearch(
-	query: string,
-	type: string | undefined,
-	limit: number,
-): Promise<SemanticResult[]> {
-	const typeMap: Record<string, string> = {
-		handoffs: "handoff",
-		observations: "observation",
-		beads: "bead",
-		project: "project",
-		templates: "template",
-	};
-
-	const fileType = type && type !== "all" ? typeMap[type] : undefined;
-	const docs = await searchVectorStore(query, limit * 2, fileType); // Fetch extra for decay filtering
-
-	// Build content map for decay calculation
-	const contents = new Map<string, string>();
-	for (const doc of docs) {
-		try {
-			const content = await fs.readFile(doc.file_path, "utf-8");
-			contents.set(doc.file_path, content);
-		} catch {
-			// File not found, skip
-		}
-	}
-
-	const results: SemanticResult[] = docs.map((doc) => ({
-		file: doc.file_path,
-		title: doc.title,
-		preview: doc.content_preview,
-		type: doc.file_type,
-		score: 1.0,
-	}));
-
-	// Apply confidence decay and re-sort
-	const decayedResults = applyConfidenceDecay(results, contents);
-	decayedResults.sort((a, b) => (b.score || 0) - (a.score || 0));
-
-	return decayedResults.slice(0, limit);
-}
-
 function formatKeywordResults(
 	query: string,
 	results: SearchResult[],
 	limit: number,
 ): string {
 	if (results.length === 0) {
-		return `No keyword matches found for "${query}".\n\nTip: Try 'mode: semantic' for conceptual search, or run 'vector-store rebuild' first.`;
+		return `No matches found for "${query}".`;
 	}
 
-	let output = `# Keyword Search: "${query}"\n\n`;
+	let output = `# Search: "${query}"\n\n`;
 	output += `Found ${results.length} file(s) with matches.\n\n`;
 
 	for (const result of results) {
@@ -234,138 +120,6 @@ function formatKeywordResults(
 		if (result.matches.length > limit) {
 			output += `- ... and ${result.matches.length - limit} more matches\n`;
 		}
-		// Add LSP navigation hint for code files
-		if (
-			result.file.endsWith(".ts") ||
-			result.file.endsWith(".tsx") ||
-			result.file.endsWith(".js") ||
-			result.file.endsWith(".jsx") ||
-			result.file.endsWith(".py") ||
-			result.file.endsWith(".go") ||
-			result.file.endsWith(".rs")
-		) {
-			const lineNum = result.matches[0]?.line;
-			if (lineNum) {
-				output += "\n🔍 **LSP Nudge:**\n";
-				output += `  \`lsp_lsp_goto_definition({ filePath: "${result.file}", line: ${lineNum}, character: 1 })\`\n`;
-			}
-		}
-		output += "\n";
-	}
-
-	return output;
-}
-
-function formatSemanticResults(
-	query: string,
-	results: SemanticResult[],
-): string {
-	if (results.length === 0) {
-		return `No semantic matches found for "${query}".\n\nTip: Run 'vector-store rebuild' to index memory files first.`;
-	}
-
-	let output = `# Semantic Search: "${query}"\n\n`;
-	output += `Found ${results.length} similar document(s).\n\n`;
-
-	const confidenceIcons: Record<string, string> = {
-		high: "🟢",
-		medium: "🟡",
-		low: "🔴",
-	};
-
-	for (const result of results) {
-		output += `## ${result.title}\n\n`;
-		output += `**File:** \`${result.file}\`\n`;
-		output += `**Type:** ${result.type}`;
-		if (result.confidence) {
-			const icon = confidenceIcons[result.confidence] || "";
-			output += ` | **Confidence:** ${icon} ${result.confidence}`;
-		}
-		if (result.age_days !== undefined && result.age_days > 0) {
-			output += ` | **Age:** ${result.age_days}d`;
-		}
-		output += "\n\n";
-		output += `${result.preview}...\n\n`;
-
-		// Add LSP navigation for code files
-		if (
-			result.file.endsWith(".ts") ||
-			result.file.endsWith(".tsx") ||
-			result.file.endsWith(".js") ||
-			result.file.endsWith(".jsx") ||
-			result.file.endsWith(".py") ||
-			result.file.endsWith(".go") ||
-			result.file.endsWith(".rs")
-		) {
-			output += "\n🔍 **LSP Nudge:**\n";
-			output += `  Get symbols: \`lsp_lsp_document_symbols({ filePath: "${result.file}" })\`\n`;
-			output += `  Find references: \`lsp_lsp_find_references({ filePath: "${result.file}", line: 1, character: 1 })\`\n`;
-		}
-
-		output += "---\n\n";
-	}
-
-	return output;
-}
-
-function formatHybridResults(
-	query: string,
-	keywordResults: SearchResult[],
-	semanticResults: SemanticResult[],
-	limit: number,
-): string {
-	let output = `# Hybrid Search: "${query}"\n\n`;
-
-	// Semantic results first (conceptual matches)
-	output += `## Semantic Matches (${semanticResults.length})\n\n`;
-	if (semanticResults.length === 0) {
-		output += `_No semantic matches. Run 'vector-store rebuild' to enable._\n\n`;
-	} else {
-		for (const result of semanticResults.slice(0, limit)) {
-			output += `- **${result.title}** (\`${result.file}\`)\n`;
-			output += `  ${result.preview.substring(0, 100)}...\n`;
-			// Add LSP hint for code files
-			if (
-				result.file.endsWith(".ts") ||
-				result.file.endsWith(".tsx") ||
-				result.file.endsWith(".js") ||
-				result.file.endsWith(".jsx") ||
-				result.file.endsWith(".py") ||
-				result.file.endsWith(".go") ||
-				result.file.endsWith(".rs")
-			) {
-				output += `  🔍 **LSP Nudge:** \`lsp_lsp_document_symbols({ filePath: "${result.file}" })\`\n`;
-			}
-		}
-		output += "\n";
-	}
-
-	// Keyword results (exact matches)
-	output += `## Keyword Matches (${keywordResults.length})\n\n`;
-	if (keywordResults.length === 0) {
-		output += "_No exact keyword matches._\n\n";
-	} else {
-		for (const result of keywordResults.slice(0, limit)) {
-			output += `- **${result.file}**\n`;
-			for (const match of result.matches.slice(0, 2)) {
-				output += `  - Line ${match.line}: ${match.content.substring(0, 80)}...\n`;
-			}
-			// Add LSP hint for code files
-			if (
-				result.file.endsWith(".ts") ||
-				result.file.endsWith(".tsx") ||
-				result.file.endsWith(".js") ||
-				result.file.endsWith(".jsx") ||
-				result.file.endsWith(".py") ||
-				result.file.endsWith(".go") ||
-				result.file.endsWith(".rs")
-			) {
-				const lineNum = result.matches[0]?.line;
-				if (lineNum) {
-					output += `  🔍 **LSP Nudge:** \`lsp_lsp_goto_definition({ filePath: "${result.file}", line: ${lineNum}, character: 1 })\`\n`;
-				}
-			}
-		}
 		output += "\n";
 	}
 
@@ -374,19 +128,11 @@ function formatHybridResults(
 
 export default tool({
 	description:
-		"Search across all memory files using keywords, semantic similarity, or hybrid mode. Returns matching files with context. Useful for finding past decisions, research, or handoffs.",
+		"Search across all memory files using keywords. Returns matching files with context. Useful for finding past decisions, research, or handoffs.",
 	args: {
 		query: tool.schema
 			.string()
-			.describe(
-				"Search query: keywords, regex pattern, or natural language for semantic search",
-			),
-		mode: tool.schema
-			.enum(["keyword", "semantic", "hybrid"])
-			.optional()
-			.describe(
-				"Search mode: 'keyword' (default, regex matching), 'semantic' (vector similarity), 'hybrid' (both)",
-			),
+			.describe("Search query: keywords or regex pattern"),
 		type: tool.schema
 			.string()
 			.optional()
@@ -395,38 +141,9 @@ export default tool({
 			),
 		limit: tool.schema.number().optional().describe("Max results (default: 5)"),
 	},
-	execute: async (args: {
-		query: string;
-		mode?: "keyword" | "semantic" | "hybrid";
-		type?: string;
-		limit?: number;
-	}) => {
-		const mode = args.mode || "keyword";
+	execute: async (args: { query: string; type?: string; limit?: number }) => {
 		const limit = args.limit || 5;
-
-		if (mode === "keyword") {
-			const results = await keywordSearch(args.query, args.type, limit);
-			return formatKeywordResults(args.query, results, limit);
-		}
-
-		if (mode === "semantic") {
-			const results = await semanticSearch(args.query, args.type, limit);
-			return formatSemanticResults(args.query, results);
-		}
-
-		if (mode === "hybrid") {
-			const [keywordResults, semanticResults] = await Promise.all([
-				keywordSearch(args.query, args.type, limit),
-				semanticSearch(args.query, args.type, limit),
-			]);
-			return formatHybridResults(
-				args.query,
-				keywordResults,
-				semanticResults,
-				limit,
-			);
-		}
-
-		return "Unknown search mode";
+		const results = await keywordSearch(args.query, args.type, limit);
+		return formatKeywordResults(args.query, results, limit);
 	},
 });