opencodekit 0.23.1 → 0.23.2

package/dist/template/.opencode/plugin/memory/validate.ts

@@ -14,7 +14,7 @@
  */
 
 import type { ObservationInput, ObservationRow } from "./db/types.js";
-import { getMemoryDB } from "./db.js";
+import { getMemoryDB } from "./db/schema.js";
 import { hasWord } from "./helpers.js";
 import { appendOperationLog } from "./operation-log.js";
 
@@ -25,17 +25,17 @@ import { appendOperationLog } from "./operation-log.js";
 export type ValidationVerdict = "pass" | "warn" | "reject";
 
 export interface ValidationResult {
-	verdict: ValidationVerdict;
-	issues: ValidationIssue[];
-	/** If a near-duplicate was found, its ID */
-	duplicateOf?: number;
+  verdict: ValidationVerdict;
+  issues: ValidationIssue[];
+  /** If a near-duplicate was found, its ID */
+  duplicateOf?: number;
 }
 
 export interface ValidationIssue {
-	type: "duplicate" | "near-duplicate" | "contradiction" | "low-quality";
-	severity: "high" | "medium" | "low";
-	message: string;
-	relatedId?: number;
+  type: "duplicate" | "near-duplicate" | "contradiction" | "low-quality";
+  severity: "high" | "medium" | "low";
+  message: string;
+  relatedId?: number;
 }
 
 // ============================================================================
@@ -47,87 +47,82 @@ export interface ValidationIssue {
  * Returns verdict (pass/warn/reject) with issues.
  */
 export function validateObservation(input: ObservationInput): ValidationResult {
-	const issues: ValidationIssue[] = [];
-
-	// Check 1: Exact title duplicate
-	const exactDup = findExactDuplicate(input);
-	if (exactDup) {
-		// If it's explicitly superseding, that's fine
-		if (input.supersedes === exactDup.id) {
-			// Intentional supersede — pass
-		} else {
-			issues.push({
-				type: "duplicate",
-				severity: "high",
-				message: `Exact duplicate of #${exactDup.id}: "${exactDup.title}"`,
-				relatedId: exactDup.id,
-			});
-
-			appendOperationLog({
-				operation: "observation-duplicate-warning",
-				targets: [`#${exactDup.id}`],
-				summary: `Duplicate warning: "${input.title}" (matches #${exactDup.id})`,
-			});
-
-			return {
-				verdict: "warn",
-				issues,
-				duplicateOf: exactDup.id,
-			};
-		}
-	}
-
-	// Check 2: Near-duplicate via FTS5
-	const nearDup = findNearDuplicate(input);
-	if (nearDup) {
-		issues.push({
-			type: "near-duplicate",
-			severity: "medium",
-			message: `Similar to #${nearDup.id}: "${nearDup.title}" (consider superseding)`,
-			relatedId: nearDup.id,
-		});
-	}
-
-	// Check 3: Contradiction with existing decisions
-	if (input.type === "decision") {
-		const contradiction = findContradiction(input);
-		if (contradiction) {
-			issues.push({
-				type: "contradiction",
-				severity: "medium",
-				message: `May contradict #${contradiction.id}: "${contradiction.title}"`,
-				relatedId: contradiction.id,
-			});
-		}
-	}
-
-	// Check 4: Low quality (no narrative, no concepts)
-	if (!input.narrative && !input.concepts) {
-		issues.push({
-			type: "low-quality",
-			severity: "low",
-			message:
-				"Observation has no narrative and no concepts — low knowledge value",
-		});
-	}
-
-	// Determine verdict
-	const hasHigh = issues.some((i) => i.severity === "high");
-	const verdict: ValidationVerdict = hasHigh
-		? "reject"
-		: issues.length > 0
-			? "warn"
-			: "pass";
-
-	if (verdict === "pass" || verdict === "warn") {
-		appendOperationLog({
-			operation: "observation-validated",
-			targets: [input.title],
-			summary: `Validated [${input.type}] "${input.title}" — ${verdict}${issues.length > 0 ? ` (${issues.length} issues)` : ""}`,
-		});
-	}
-
-	return { verdict, issues };
+  const issues: ValidationIssue[] = [];
+
+  // Check 1: Exact title duplicate
+  const exactDup = findExactDuplicate(input);
+  if (exactDup) {
+    // If it's explicitly superseding, that's fine
+    if (input.supersedes === exactDup.id) {
+      // Intentional supersede — pass
+    } else {
+      issues.push({
+        type: "duplicate",
+        severity: "high",
+        message: `Exact duplicate of #${exactDup.id}: "${exactDup.title}"`,
+        relatedId: exactDup.id,
+      });
+
+      appendOperationLog({
+        operation: "observation-duplicate-warning",
+        targets: [`#${exactDup.id}`],
+        summary: `Duplicate warning: "${input.title}" (matches #${exactDup.id})`,
+      });
+
+      return {
+        verdict: "warn",
+        issues,
+        duplicateOf: exactDup.id,
+      };
+    }
+  }
+
+  // Check 2: Near-duplicate via FTS5
+  const nearDup = findNearDuplicate(input);
+  if (nearDup) {
+    issues.push({
+      type: "near-duplicate",
+      severity: "medium",
+      message: `Similar to #${nearDup.id}: "${nearDup.title}" (consider superseding)`,
+      relatedId: nearDup.id,
+    });
+  }
+
+  // Check 3: Contradiction with existing decisions
+  if (input.type === "decision") {
+    const contradiction = findContradiction(input);
+    if (contradiction) {
+      issues.push({
+        type: "contradiction",
+        severity: "medium",
+        message: `May contradict #${contradiction.id}: "${contradiction.title}"`,
+        relatedId: contradiction.id,
+      });
+    }
+  }
+
+  // Check 4: Low quality (no narrative, no concepts)
+  if (!input.narrative && !input.concepts) {
+    issues.push({
+      type: "low-quality",
+      severity: "low",
+      message: "Observation has no narrative and no concepts — low knowledge value",
+    });
+  }
+
+  // Determine verdict
+  const hasHigh = issues.some((i) => i.severity === "high");
+  const verdict: ValidationVerdict = hasHigh ? "reject" : issues.length > 0 ? "warn" : "pass";
+
+  if (verdict === "pass" || verdict === "warn") {
+    appendOperationLog({
+      operation: "observation-validated",
+      targets: [input.title],
+      summary: `Validated [${input.type}] "${input.title}" — ${verdict}${issues.length > 0 ? ` (${issues.length} issues)` : ""}`,
+    });
+  }
+
+  return { verdict, issues };
 }
 
 // ============================================================================
@@ -138,106 +133,101 @@ export function validateObservation(input: ObservationInput): ValidationResult {
  * Check for exact title match (same type, active).
  */
 function findExactDuplicate(input: ObservationInput): ObservationRow | null {
-	const db = getMemoryDB();
-	return db
-		.query(
-			`SELECT * FROM observations
+  const db = getMemoryDB();
+  return db
+    .query(
+      `SELECT * FROM observations
 			 WHERE type = ? AND LOWER(title) = LOWER(?) AND superseded_by IS NULL
 			 LIMIT 1`,
-		)
-		.get(input.type, input.title) as ObservationRow | null;
+    )
+    .get(input.type, input.title) as ObservationRow | null;
 }
 
 /**
  * Check for near-duplicate via FTS5 title search.
  */
 function findNearDuplicate(input: ObservationInput): ObservationRow | null {
-	const db = getMemoryDB();
-
-	// Build FTS query from title words
-	// Strip FTS5 special operators and characters to prevent query syntax errors
-	const FTS5_OPERATORS = /\b(AND|OR|NOT|NEAR)\b/gi;
-	const words = input.title
-		.replace(FTS5_OPERATORS, "")
-		.replace(/['"*^+(){}]/g, "")
-		.split(/\s+/)
-		.filter((w) => w.length > 2)
-		.map((w) => `"${w}"*`)
-		.join(" AND ");
-
-	if (!words) return null;
-
-	try {
-		const result = db
-			.query(
-				`SELECT o.* FROM observations o
+  const db = getMemoryDB();
+
+  // Build FTS query from title words
+  // Strip FTS5 special operators and characters to prevent query syntax errors
+  const FTS5_OPERATORS = /\b(AND|OR|NOT|NEAR)\b/gi;
+  const words = input.title
+    .replace(FTS5_OPERATORS, "")
+    .replace(/['"*^+(){}]/g, "")
+    .split(/\s+/)
+    .filter((w) => w.length > 2)
+    .map((w) => `"${w}"*`)
+    .join(" AND ");
+
+  if (!words) return null;
+
+  try {
+    const result = db
+      .query(
+        `SELECT o.* FROM observations o
 				 JOIN observations_fts fts ON fts.rowid = o.id
 				 WHERE observations_fts MATCH ?
 				   AND o.type = ?
 				   AND o.superseded_by IS NULL
 				   AND o.id != COALESCE(?, -1)
 				 ORDER BY bm25(observations_fts) LIMIT 1`,
-			)
-			.get(
-				words,
-				input.type,
-				input.supersedes ?? null,
-			) as ObservationRow | null;
-
-		return result;
-	} catch {
-		return null;
-	}
+      )
+      .get(words, input.type, input.supersedes ?? null) as ObservationRow | null;
+
+    return result;
+  } catch {
+    return null;
+  }
 }
 
 /**
  * Check for contradictions with existing decisions.
  */
 function findContradiction(input: ObservationInput): ObservationRow | null {
-	if (!input.concepts || input.concepts.length === 0) return null;
+  if (!input.concepts || input.concepts.length === 0) return null;
 
-	const db = getMemoryDB();
+  const db = getMemoryDB();
 
-	// Search for decisions with overlapping concepts
-	const conceptQuery = input.concepts.map((c) => `"${c}"*`).join(" OR ");
+  // Search for decisions with overlapping concepts
+  const conceptQuery = input.concepts.map((c) => `"${c}"*`).join(" OR ");
 
-	try {
-		const candidates = db
-			.query(
-				`SELECT o.* FROM observations o
+  try {
+    const candidates = db
+      .query(
+        `SELECT o.* FROM observations o
 				 JOIN observations_fts fts ON fts.rowid = o.id
 				 WHERE observations_fts MATCH ?
 				   AND o.type = 'decision'
 				   AND o.superseded_by IS NULL
 				 ORDER BY bm25(observations_fts) LIMIT 5`,
-			)
-			.all(conceptQuery) as ObservationRow[];
-
-		// Check for opposing signals
-		const inputText = `${input.title} ${input.narrative ?? ""}`.toLowerCase();
-		const contradictionPairs = [
-			["use", "don't use"],
-			["enable", "disable"],
-			["add", "remove"],
-			["prefer", "avoid"],
-			["always", "never"],
-		];
-
-		for (const candidate of candidates) {
-			const candidateText =
-				`${candidate.title} ${candidate.narrative ?? ""}`.toLowerCase();
-			for (const [wordA, wordB] of contradictionPairs) {
-				if (
-					(hasWord(inputText, wordA) && hasWord(candidateText, wordB)) ||
-					(hasWord(inputText, wordB) && hasWord(candidateText, wordA))
-				) {
-					return candidate;
-				}
-			}
-		}
-	} catch {
-		// FTS5 query failed
-	}
-
-	return null;
+      )
+      .all(conceptQuery) as ObservationRow[];
+
+    // Check for opposing signals
+    const inputText = `${input.title} ${input.narrative ?? ""}`.toLowerCase();
+    const contradictionPairs = [
+      ["use", "don't use"],
+      ["enable", "disable"],
+      ["add", "remove"],
+      ["prefer", "avoid"],
+      ["always", "never"],
+    ];
+
+    for (const candidate of candidates) {
+      const candidateText = `${candidate.title} ${candidate.narrative ?? ""}`.toLowerCase();
+      for (const [wordA, wordB] of contradictionPairs) {
+        if (
+          (hasWord(inputText, wordA) && hasWord(candidateText, wordB)) ||
+          (hasWord(inputText, wordB) && hasWord(candidateText, wordA))
+        ) {
+          return candidate;
+        }
+      }
+    }
+  } catch {
+    // FTS5 query failed
+  }
+
+  return null;
 }

package/dist/template/.opencode/plugin/sdk/copilot/responses/tool/web-search-preview.ts

@@ -1,5 +1,6 @@
-import { createProviderToolFactory } from "@ai-sdk/provider-utils"
-import { z } from "zod/v4"
+import { createProviderToolFactory } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+import { webSearchInputSchema } from "./web-search-shared.js";
 
 // Args validation schema
 export const webSearchPreviewArgsSchema = z.object({
@@ -38,7 +39,7 @@ export const webSearchPreviewArgsSchema = z.object({
       timezone: z.string().optional(),
     })
     .optional(),
-})
+});
 
 export const webSearchPreview = createProviderToolFactory<
   {
@@ -51,7 +52,7 @@ export const webSearchPreview = createProviderToolFactory<
      * - medium: Balanced context, cost, and latency (default)
      * - low: Least context, lowest cost, fastest response
      */
-    searchContextSize?: "low" | "medium" | "high"
+    searchContextSize?: "low" | "medium" | "high";
 
     /**
      * User location information to provide geographically relevant search results.
@@ -60,44 +61,26 @@ export const webSearchPreview = createProviderToolFactory<
       /**
        * Type of location (always 'approximate')
        */
-      type: "approximate"
+      type: "approximate";
       /**
        * Two-letter ISO country code (e.g., 'US', 'GB')
        */
-      country?: string
+      country?: string;
       /**
        * City name (free text, e.g., 'Minneapolis')
        */
-      city?: string
+      city?: string;
       /**
        * Region name (free text, e.g., 'Minnesota')
        */
-      region?: string
+      region?: string;
       /**
        * IANA timezone (e.g., 'America/Chicago')
        */
-      timezone?: string
-    }
+      timezone?: string;
+    };
   }
 >({
   id: "openai.web_search_preview",
-  inputSchema: z.object({
-    action: z
-      .discriminatedUnion("type", [
-        z.object({
-          type: z.literal("search"),
-          query: z.string().nullish(),
-        }),
-        z.object({
-          type: z.literal("open_page"),
-          url: z.string(),
-        }),
-        z.object({
-          type: z.literal("find"),
-          url: z.string(),
-          pattern: z.string(),
-        }),
-      ])
-      .nullish(),
-  }),
-})
+  inputSchema: webSearchInputSchema,
+});

package/dist/template/.opencode/plugin/sdk/copilot/responses/tool/web-search-shared.ts

@@ -0,0 +1,25 @@
+import { z } from "zod/v4";
+
+/**
+ * Shared input schema for web search tool actions.
+ * Both search and search-preview tools use the same action types.
+ */
+export const webSearchInputSchema = z.object({
+  action: z
+    .discriminatedUnion("type", [
+      z.object({
+        type: z.literal("search"),
+        query: z.string().nullish(),
+      }),
+      z.object({
+        type: z.literal("open_page"),
+        url: z.string(),
+      }),
+      z.object({
+        type: z.literal("find"),
+        url: z.string(),
+        pattern: z.string(),
+      }),
+    ])
+    .nullish(),
+});

package/dist/template/.opencode/plugin/sdk/copilot/responses/tool/web-search.ts

@@ -1,5 +1,6 @@
-import { createProviderToolFactory } from "@ai-sdk/provider-utils"
-import { z } from "zod/v4"
+import { createProviderToolFactory } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+import { webSearchInputSchema } from "./web-search-shared.js";
 
 export const webSearchArgsSchema = z.object({
   filters: z
@@ -19,7 +20,7 @@ export const webSearchArgsSchema = z.object({
       timezone: z.string().optional(),
     })
     .optional(),
-})
+});
 
 export const webSearchToolFactory = createProviderToolFactory<
   {
@@ -35,8 +36,8 @@ export const webSearchToolFactory = createProviderToolFactory<
        * If not provided, all domains are allowed.
        * Subdomains of the provided domains are allowed as well.
        */
-      allowedDomains?: string[]
-    }
+      allowedDomains?: string[];
+    };
 
     /**
      * Search context size to use for the web search.
@@ -44,7 +45,7 @@ export const webSearchToolFactory = createProviderToolFactory<
      * - medium: Balanced context, cost, and latency (default)
      * - low: Least context, lowest cost, fastest response
      */
-    searchContextSize?: "low" | "medium" | "high"
+    searchContextSize?: "low" | "medium" | "high";
 
     /**
      * User location information to provide geographically relevant search results.
@@ -53,50 +54,32 @@ export const webSearchToolFactory = createProviderToolFactory<
       /**
        * Type of location (always 'approximate')
        */
-      type: "approximate"
+      type: "approximate";
       /**
        * Two-letter ISO country code (e.g., 'US', 'GB')
        */
-      country?: string
+      country?: string;
       /**
        * City name (free text, e.g., 'Minneapolis')
        */
-      city?: string
+      city?: string;
       /**
        * Region name (free text, e.g., 'Minnesota')
        */
-      region?: string
+      region?: string;
       /**
        * IANA timezone (e.g., 'America/Chicago')
        */
-      timezone?: string
-    }
+      timezone?: string;
+    };
   }
 >({
   id: "openai.web_search",
-  inputSchema: z.object({
-    action: z
-      .discriminatedUnion("type", [
-        z.object({
-          type: z.literal("search"),
-          query: z.string().nullish(),
-        }),
-        z.object({
-          type: z.literal("open_page"),
-          url: z.string(),
-        }),
-        z.object({
-          type: z.literal("find"),
-          url: z.string(),
-          pattern: z.string(),
-        }),
-      ])
-      .nullish(),
-  }),
-})
+  inputSchema: webSearchInputSchema,
+});
 
 export const webSearch = (
   args: Parameters<typeof webSearchToolFactory>[0] = {}, // default
 ) => {
-  return webSearchToolFactory(args)
-}
+  return webSearchToolFactory(args);
+};