oh-my-llmwikimode 1.0.0

package/src/hooks.js

@@ -0,0 +1,199 @@
+/**
+ * Hook utilities for oh-my-llmwikimode
+ *
+ * Safe message parsing and event handling for OpenCode hooks.
+ */
+
+/**
+ * Extract text content from output.parts array.
+ *
+ * OpenCode UserMessage text is represented in parts, not in message.text.
+ * This utility safely extracts text from text parts only.
+ *
+ * @param {Array} parts - output.parts from chat.message hook
+ * @returns {string} - Joined text content
+ */
+export function extractTextFromParts(parts) {
+  if (!Array.isArray(parts)) {
+    return "";
+  }
+
+  const texts = [];
+  for (const part of parts) {
+    if (part && typeof part.text === "string") {
+      texts.push(part.text);
+    }
+  }
+
+  return texts.join("");
+}
+
+/**
+ * Check if text contains problem-solving patterns.
+ *
+ * @param {string} text
+ * @returns {boolean}
+ */
+export function hasProblemPattern(text) {
+  if (!text || typeof text !== "string") {
+    return false;
+  }
+
+  const problemKeywords = [
+    "bug", "error", "fail", "crash", "issue", "problem",
+    "exception", "broken", "not working", "fails",
+    "버그", "오류", "실패", "문제", "에러", "오작동",
+  ];
+
+  const lowerText = text.toLowerCase();
+  return problemKeywords.some((kw) => lowerText.includes(kw.toLowerCase()));
+}
+
+/**
+ * Check if text is an explicit request to save knowledge for later.
+ *
+ * These requests should be handled by the wiki_store tool so the stored entry
+ * is curated instead of auto-capturing the raw user prompt as a duplicate.
+ *
+ * @param {string} text
+ * @returns {boolean}
+ */
+export function hasExplicitStorageRequest(text) {
+  if (!text || typeof text !== "string") {
+    return false;
+  }
+
+  const lowerText = text.toLowerCase();
+  const storagePatterns = [
+    "save this",
+    "store this",
+    "remember this",
+    "save this lesson",
+    "for next time",
+    "for later",
+    "note this",
+    "저장해줘",
+    "저장해 줘",
+    "저장해둬",
+    "저장해 둬",
+    "기억해줘",
+    "기억해 줘",
+    "기록해줘",
+    "기록해 줘",
+    "다음에 참고",
+    "나중에 참고",
+  ];
+
+  return storagePatterns.some((pattern) => lowerText.includes(pattern));
+}
+
+/**
+ * Check if text is an internal orchestration prompt rather than user knowledge.
+ *
+ * These prompts can contain words like "problem" or "debugging", but storing
+ * them pollutes the wiki with agent instructions instead of reusable lessons.
+ *
+ * @param {string} text
+ * @returns {boolean}
+ */
+export function hasInternalInstructionPattern(text) {
+  if (!text || typeof text !== "string") {
+    return false;
+  }
+
+  const lowerText = text.toLowerCase();
+  const internalPatterns = [
+    "[analyze-mode]",
+    "[search-mode]",
+    "analysis mode. gather context before diving deep",
+    "maximize search effort",
+    "launch multiple background agents",
+    "mandatory delegate_task params",
+    "<!-- omo_internal_initiator -->",
+  ];
+
+  if (internalPatterns.some((pattern) => lowerText.includes(pattern))) {
+    return true;
+  }
+
+  return /1\.\s*task:/i.test(text)
+    && /2\.\s*expected outcome:/i.test(text)
+    && /3\.\s*required tools:/i.test(text)
+    && /4\.\s*must do:/i.test(text)
+    && /5\.\s*must not do:/i.test(text)
+    && /6\.\s*context:/i.test(text);
+}
+
+/**
+ * Check if text contains privacy opt-out phrases.
+ *
+ * @param {string} text
+ * @returns {boolean}
+ */
+export function hasPrivacyOptOut(text) {
+  if (!text || typeof text !== "string") {
+    return false;
+  }
+
+  const lowerText = text.toLowerCase();
+  const optOutPatterns = [
+    "do not store",
+    "do not save",
+    "don't store",
+    "don't save",
+    "private",
+    "sensitive",
+    "confidential",
+    "personal",
+    "off the record",
+    "not for storage",
+    "no storage",
+    "저장하지 마",
+    "저장 말아",
+    "비밀",
+    "기밀",
+    "개인정보",
+    "민감정보",
+  ];
+
+  return optOutPatterns.some((pattern) => lowerText.includes(pattern.toLowerCase()));
+}
+
+/**
+ * Check if text exceeds safe size for auto-memory.
+ *
+ * @param {string} text
+ * @param {number} maxChars - default 5000
+ * @returns {boolean}
+ */
+export function hasOversizedMessage(text, maxChars = 5000) {
+  if (!text || typeof text !== "string") {
+    return false;
+  }
+  return text.length > maxChars;
+}
+
+/**
+ * Safe event handler that only processes supported event types.
+ *
+ * @param {object} event
+ * @returns {boolean} - true if event was handled
+ */
+export function handleSupportedEvent(event) {
+  if (!event || !event.type) {
+    return false;
+  }
+
+  // Only handle explicitly supported events.
+  // Do NOT assume "startup" or any other non-documented event type exists.
+  const supportedTypes = [
+    // Add supported event types here as they are discovered/documented
+  ];
+
+  if (supportedTypes.includes(event.type)) {
+    return true;
+  }
+
+  // Silently ignore unsupported events
+  return false;
+}

package/src/librarian/schema.js

@@ -0,0 +1,218 @@
+import { redactSecrets } from "../security.js";
+
+export const LIBRARIAN_REVIEW_STATUS = "review_required";
+export const DEFAULT_BUILT_AT = "1970-01-01T00:00:00.000Z";
+
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function compareStrings(left, right) {
+  return String(left ?? "").localeCompare(String(right ?? ""));
+}
+
+function normalizeScalar(value, maxLength = 500) {
+  return redactSecrets(String(value ?? "")
+    .replace(/\r?\n/g, " ")
+    .replace(/\s+/g, " ")
+    .trim())
+    .slice(0, maxLength);
+}
+
+function normalizeTextBlock(value, maxLength = 20000) {
+  return redactSecrets(String(value ?? "")
+    .replace(/\r\n/g, "\n")
+    .trim())
+    .slice(0, maxLength);
+}
+
+function normalizeId(value, label = "id") {
+  const id = normalizeScalar(value, 120).toLowerCase();
+  if (!/^[a-z0-9][a-z0-9_-]{0,119}$/.test(id)) {
+    throw new Error(`Invalid ${label}: ${value}`);
+  }
+  return id;
+}
+
+function normalizeStringList(value, maxLength = 120) {
+  const values = Array.isArray(value) ? value : typeof value === "string" ? [value] : [];
+  return [...new Set(values.map((item) => normalizeScalar(item, maxLength)).filter(Boolean))]
+    .sort(compareStrings);
+}
+
+function normalizeBooleanFalse(value, label) {
+  if (value === undefined || value === null || value === false) return false;
+  throw new Error(`${label} must remain false`);
+}
+
+function normalizeReviewStatus(value) {
+  const status = normalizeScalar(value || LIBRARIAN_REVIEW_STATUS, 80).toLowerCase();
+  if (status !== LIBRARIAN_REVIEW_STATUS) {
+    throw new Error(`Librarian artifacts must stay ${LIBRARIAN_REVIEW_STATUS}`);
+  }
+  return LIBRARIAN_REVIEW_STATUS;
+}
+
+function normalizeScore(value, label) {
+  if (value === undefined || value === null || value === "") return undefined;
+  const number = Number(value);
+  if (!Number.isFinite(number)) throw new Error(`Invalid ${label} score`);
+  return Math.max(0, Math.min(1, Math.round(number * 1000) / 1000));
+}
+
+function validationResult(builder) {
+  try {
+    return { valid: true, value: builder(), errors: [] };
+  } catch (error) {
+    return { valid: false, value: null, errors: [error.message] };
+  }
+}
+
+export function normalizeLibrarianPath(value, label = "path", maxLength = 260) {
+  const normalized = normalizeScalar(value, maxLength).replace(/\\/g, "/");
+  if (!normalized) throw new Error(`Unsafe ${label}: path is required`);
+  if (/^[a-z]:\//i.test(normalized) || normalized.startsWith("/") || normalized.startsWith("//")) {
+    throw new Error(`Unsafe ${label}: absolute paths are not allowed`);
+  }
+  if (normalized.split("/").some((segment) => segment === "..")) {
+    throw new Error(`Unsafe ${label}: traversal is not allowed`);
+  }
+  return normalized;
+}
+
+function normalizeDigestEntry(input, label = "digest entry") {
+  if (!isRecord(input)) throw new Error(`${label} must be an object`);
+  const entry = {
+    path: normalizeLibrarianPath(input.path, `${label} path`),
+    title: normalizeScalar(input.title || input.path, 180),
+    status: normalizeScalar(input.status || "candidate", 80).toLowerCase(),
+    category: normalizeScalar(input.category || "", 80).toLowerCase(),
+    source: normalizeScalar(input.source || "", 120).toLowerCase(),
+    tags: normalizeStringList(input.tags, 80),
+    summary: normalizeScalar(input.summary, 240),
+    created_at: normalizeScalar(input.created_at || input.createdAt, 80),
+    updated_at: normalizeScalar(input.updated_at || input.updatedAt, 80),
+  };
+
+  const confidence = normalizeScore(input.confidence_score ?? input.confidenceScore, "confidence");
+  if (confidence !== undefined) entry.confidence_score = confidence;
+
+  const degree = Number(input.graph_degree ?? input.graphDegree);
+  if (Number.isFinite(degree)) entry.graph_degree = Math.max(0, Math.trunc(degree));
+
+  const daysSinceUpdate = Number(input.days_since_update ?? input.daysSinceUpdate);
+  if (Number.isFinite(daysSinceUpdate)) entry.days_since_update = Math.max(0, Math.trunc(daysSinceUpdate));
+
+  const reason = normalizeScalar(input.reason, 240);
+  if (reason) entry.reason = reason;
+
+  return entry;
+}
+
+function normalizeDigestEntries(value, label) {
+  const entries = Array.isArray(value) ? value : [];
+  return entries.map((entry) => normalizeDigestEntry(entry, label));
+}
+
+function normalizeDuplicateCandidate(input) {
+  if (!isRecord(input)) throw new Error("duplicate candidate must be an object");
+  const type = normalizeScalar(input.type || "unknown", 40).toLowerCase();
+  const duplicate = {
+    type,
+    entries: normalizeStringList(input.entries, 260).map((entryPath) => normalizeLibrarianPath(entryPath, "duplicate entry path")),
+  };
+  if (duplicate.entries.length < 2) throw new Error("duplicate candidate requires at least two entries");
+
+  const normalizedTitle = normalizeScalar(input.normalized_title || input.normalizedTitle, 160);
+  const hash = normalizeScalar(input.hash, 80);
+  if (normalizedTitle) duplicate.normalized_title = normalizedTitle;
+  if (hash) duplicate.hash = hash;
+  return duplicate;
+}
+
+function normalizeDuplicateCandidates(value) {
+  const candidates = Array.isArray(value) ? value : [];
+  return candidates.map(normalizeDuplicateCandidate);
+}
+
+function normalizeSections(value = {}) {
+  const sections = isRecord(value) ? value : {};
+  return {
+    new_entries: normalizeDigestEntries(sections.new_entries || sections.newEntries, "new entry"),
+    orphaned_entries: normalizeDigestEntries(sections.orphaned_entries || sections.orphanedEntries, "orphaned entry"),
+    duplicate_candidates: normalizeDuplicateCandidates(sections.duplicate_candidates || sections.duplicateCandidates),
+    stale_entries: normalizeDigestEntries(sections.stale_entries || sections.staleEntries, "stale entry"),
+    promotion_suggestions: normalizeDigestEntries(sections.promotion_suggestions || sections.promotionSuggestions, "promotion suggestion"),
+  };
+}
+
+function normalizeBoundaries(value = {}) {
+  const boundaries = isRecord(value) ? value : {};
+  return {
+    executed: normalizeBooleanFalse(boundaries.executed, "executed"),
+    mutates_sources: normalizeBooleanFalse(boundaries.mutates_sources || boundaries.mutatesSources, "mutates_sources"),
+    auto_promote: normalizeBooleanFalse(boundaries.auto_promote || boundaries.autoPromote, "auto_promote"),
+    auto_merge: normalizeBooleanFalse(boundaries.auto_merge || boundaries.autoMerge, "auto_merge"),
+    auto_delete: normalizeBooleanFalse(boundaries.auto_delete || boundaries.autoDelete, "auto_delete"),
+  };
+}
+
+function sourcePathsFromSections(sections) {
+  return normalizeStringList([
+    ...sections.new_entries.map((entry) => entry.path),
+    ...sections.orphaned_entries.map((entry) => entry.path),
+    ...sections.stale_entries.map((entry) => entry.path),
+    ...sections.promotion_suggestions.map((entry) => entry.path),
+    ...sections.duplicate_candidates.flatMap((duplicate) => duplicate.entries),
+  ], 260).map((entryPath) => normalizeLibrarianPath(entryPath, "source path"));
+}
+
+function normalizeSummaryCounts(input, sections) {
+  const counts = isRecord(input) ? input : {};
+  return {
+    total_entries: Number.isFinite(Number(counts.total_entries || counts.totalEntries)) ? Math.max(0, Math.trunc(Number(counts.total_entries || counts.totalEntries))) : 0,
+    new_entries: sections.new_entries.length,
+    orphaned_entries: sections.orphaned_entries.length,
+    duplicate_candidates: sections.duplicate_candidates.length,
+    stale_entries: sections.stale_entries.length,
+    promotion_suggestions: sections.promotion_suggestions.length,
+  };
+}
+
+function normalizePeriod(input = {}) {
+  const period = isRecord(input) ? input : {};
+  return {
+    start: normalizeScalar(period.start, 80),
+    end: normalizeScalar(period.end, 80),
+    days: Number.isFinite(Number(period.days)) ? Math.max(1, Math.trunc(Number(period.days))) : 7,
+  };
+}
+
+export function validateWeeklyDigestArtifact(input) {
+  return validationResult(() => {
+    if (!isRecord(input)) throw new Error("Weekly digest artifact must be an object");
+    const sections = normalizeSections(input.sections);
+    const title = normalizeScalar(input.title || "Weekly Digest", 180);
+    const reportMarkdown = normalizeTextBlock(input.report_markdown || input.reportMarkdown, 50000);
+    if (!reportMarkdown) throw new Error("Weekly digest report_markdown is required");
+
+    return {
+      schema_version: 1,
+      id: normalizeId(input.id, "weekly digest id"),
+      type: "weekly_digest",
+      title,
+      status: normalizeReviewStatus(input.status),
+      review_required: true,
+      review_only: true,
+      period: normalizePeriod(input.period),
+      source_paths: sourcePathsFromSections(sections),
+      summary_counts: normalizeSummaryCounts(input.summary_counts || input.summaryCounts, sections),
+      sections,
+      report_markdown: reportMarkdown,
+      boundaries: normalizeBoundaries(input.boundaries),
+      created_at: normalizeScalar(input.created_at || input.createdAt || DEFAULT_BUILT_AT, 80),
+      updated_at: normalizeScalar(input.updated_at || input.updatedAt || DEFAULT_BUILT_AT, 80),
+      actor: normalizeScalar(input.actor || "system", 120),
+    };
+  });
+}