oh-my-llmwikimode 1.0.0

package/src/team/shared-memory.js

@@ -0,0 +1,183 @@
+import fs from "node:fs";
+import path from "node:path";
+import { wrapWithBoundary } from "../security.js";
+import { buildIndex, getWikiPaths } from "../wiki/store.js";
+import { queryWiki } from "../wiki/query.js";
+import { normalizeEntryStatus, normalizeEntryTags, normalizeEntryText } from "../wiki/entry-normalizer.js";
+
+const EXCLUDED_STATUSES = new Set(["rejected", "superseded", "private", "needs-clarification"]);
+
+function normalizePath(value) {
+  if (!value || typeof value !== "string") return "";
+  const normalized = value.replace(/\\/g, "/");
+  if (path.isAbsolute(normalized)) return "";
+  if (normalized.split("/").some((segment) => segment === "..")) return "";
+  return normalized;
+}
+
+function entrySummary(entry, relation = "direct") {
+  return {
+    path: entry.path,
+    title: normalizeEntryText(entry.title) || entry.path,
+    status: normalizeEntryStatus(entry.status),
+    tags: normalizeEntryTags(entry.tags),
+    confidence: entry.confidence || "EXTRACTED",
+    confidence_score: typeof entry.confidence_score === "number" ? entry.confidence_score : 1,
+    relation,
+  };
+}
+
+function isVisible(entry) {
+  return entry && !EXCLUDED_STATUSES.has(normalizeEntryStatus(entry.status));
+}
+
+function readGraph(wikiRoot) {
+  const graphPath = path.join(getWikiPaths(wikiRoot).system, "graph.json");
+  try {
+    if (!fs.existsSync(graphPath)) return { nodes: [], edges: [] };
+    const graph = JSON.parse(fs.readFileSync(graphPath, "utf-8"));
+    return {
+      nodes: Array.isArray(graph.nodes) ? graph.nodes : [],
+      edges: Array.isArray(graph.edges) ? graph.edges : [],
+    };
+  } catch {
+    return { nodes: [], edges: [] };
+  }
+}
+
+function mapEntriesByPath(index) {
+  return new Map((index.entries || []).map((entry) => [entry.path, entry]));
+}
+
+function relationEdge(edge) {
+  return {
+    source: String(edge.source || ""),
+    target: String(edge.target || ""),
+    relation: String(edge.relation || "related"),
+    confidence: edge.confidence || "EXTRACTED",
+    confidence_score: typeof edge.confidence_score === "number" ? edge.confidence_score : 1,
+  };
+}
+
+function findNodePath(graph, refPath) {
+  const node = graph.nodes.find((item) => item.id === refPath || item.path === refPath);
+  return node?.path || node?.id || refPath;
+}
+
+function resolveWikiPath(wikiRoot, index, ref) {
+  const refPath = normalizePath(ref.path);
+  if (!refPath) return { warning: "invalid wiki reference path" };
+  const entry = (index.entries || []).find((item) => item.path === refPath);
+  if (!entry) return { warning: `missing wiki reference: ${refPath}` };
+  if (!isVisible(entry)) return { warning: `excluded wiki reference: ${refPath}` };
+  const fullPath = path.join(wikiRoot, refPath);
+  if (!fs.existsSync(fullPath)) return { warning: `missing wiki file: ${refPath}` };
+  return { context: entrySummary(entry, "wiki") };
+}
+
+function resolveQuery(wikiRoot, ref) {
+  const query = String(ref.query || "").trim();
+  if (!query) return { warning: "query reference is empty" };
+  const result = queryWiki(wikiRoot, query, { maxResults: 3, format: "json" });
+  if (!result.success) return { warning: `query failed: ${result.error}` };
+  return {
+    context: [
+      ...(result.direct_matches || []).filter(isVisible).map((entry) => entrySummary(entry, "query")),
+      ...(result.graph_neighbors || []).filter(isVisible).map((entry) => entrySummary(entry, "graph_neighbor")),
+    ],
+    warnings: result.duplicate_warnings?.map((warning) => `duplicate warning: ${warning.type}`) || [],
+  };
+}
+
+function resolveGraphReference(index, graph, ref) {
+  const graphId = normalizePath(ref.graph_id || ref.graphId || ref.path);
+  if (!graphId) return { warning: "invalid graph reference" };
+  const nodePath = findNodePath(graph, graphId);
+  const entriesByPath = mapEntriesByPath(index);
+  const entry = entriesByPath.get(nodePath);
+  if (!entry) return { warning: `missing graph reference: ${graphId}` };
+  if (!isVisible(entry)) return { warning: `excluded graph reference: ${graphId}` };
+  const relationEdges = graph.edges
+    .filter((edge) => edge.source === nodePath || edge.target === nodePath)
+    .map(relationEdge);
+  return { context: entrySummary(entry, "graph"), relation_edges: relationEdges };
+}
+
+function resolveRelatedReference(index, graph, ref) {
+  const sourcePath = normalizePath(ref.path || ref.graph_id || ref.graphId);
+  if (!sourcePath) return { warning: "invalid related reference path" };
+  const entriesByPath = mapEntriesByPath(index);
+  const sourceEntry = entriesByPath.get(sourcePath);
+  if (!sourceEntry) return { warning: `missing related reference: ${sourcePath}` };
+  if (!isVisible(sourceEntry)) return { warning: `excluded related reference: ${sourcePath}` };
+
+  const relationEdges = graph.edges
+    .filter((edge) => edge.source === sourcePath && String(edge.relation || "related") === "related")
+    .map(relationEdge);
+  const context = relationEdges
+    .map((edge) => entriesByPath.get(edge.target))
+    .filter(isVisible)
+    .map((entry) => entrySummary(entry, "related"));
+  return { context, relation_edges: relationEdges };
+}
+
+function dedupeRelationEdges(edges) {
+  return [...new Map(edges
+    .filter((edge) => edge.source && edge.target)
+    .map((edge) => [`${edge.source}:${edge.target}:${edge.relation}`, edge])).values()]
+    .sort((a, b) => {
+      if (a.source !== b.source) return a.source.localeCompare(b.source);
+      if (a.target !== b.target) return a.target.localeCompare(b.target);
+      return a.relation.localeCompare(b.relation);
+    });
+}
+
+export function resolveTaskContextRefs(wikiRoot, taskCard) {
+  const index = buildIndex(wikiRoot);
+  const graph = readGraph(wikiRoot);
+  const refs = Array.isArray(taskCard?.context_refs) ? taskCard.context_refs : [];
+  const context = [];
+  const relationEdges = [];
+  const warnings = [];
+
+  for (const ref of refs) {
+    if (!ref || typeof ref !== "object") continue;
+    if (ref.type === "wiki") {
+      const result = resolveWikiPath(wikiRoot, index, ref);
+      if (result.context) context.push(result.context);
+      if (result.warning) warnings.push(result.warning);
+    } else if (ref.type === "query") {
+      const result = resolveQuery(wikiRoot, ref);
+      if (Array.isArray(result.context)) context.push(...result.context);
+      if (Array.isArray(result.warnings)) warnings.push(...result.warnings);
+      if (result.warning) warnings.push(result.warning);
+    } else if (ref.type === "graph") {
+      const result = resolveGraphReference(index, graph, ref);
+      if (result.context) context.push(result.context);
+      if (Array.isArray(result.relation_edges)) relationEdges.push(...result.relation_edges);
+      if (result.warning) warnings.push(result.warning);
+    } else if (ref.type === "related") {
+      const result = resolveRelatedReference(index, graph, ref);
+      if (Array.isArray(result.context)) context.push(...result.context);
+      if (Array.isArray(result.relation_edges)) relationEdges.push(...result.relation_edges);
+      if (result.warning) warnings.push(result.warning);
+    } else if (ref.graph_id) {
+      warnings.push(`graph reference recorded for review: ${ref.graph_id}`);
+    }
+  }
+
+  const unique = [...new Map(context.map((item) => [item.path, item])).values()]
+    .sort((a, b) => a.path.localeCompare(b.path));
+
+  return {
+    success: true,
+    context: unique,
+    relation_edges: dedupeRelationEdges(relationEdges),
+    warnings: [...new Set(warnings)].sort((a, b) => a.localeCompare(b)),
+    boundary: wrapWithBoundary("Agent Team context references are summaries only."),
+  };
+}
+
+export function getAgentTeamSharedMemoryPath(wikiRoot) {
+  return path.join(getWikiPaths(wikiRoot).system, "agent-team", "queue.json");
+}

package/src/todo/browser-data.js

@@ -0,0 +1,71 @@
+import { DEFAULT_BUILT_AT } from "./schema.js";
+import { readTodoQueue } from "./queue.js";
+
+function compareStrings(left, right) {
+  return String(left ?? "").localeCompare(String(right ?? ""));
+}
+
+function hasSafeDate(value) {
+  return typeof value === "string" && value.trim() && !Number.isNaN(Date.parse(value));
+}
+
+function deterministicBuiltAt(todos) {
+  const dates = [];
+  for (const todo of todos) {
+    if (hasSafeDate(todo.created_at)) dates.push(todo.created_at);
+    if (hasSafeDate(todo.completed_at)) dates.push(todo.completed_at);
+  }
+  if (dates.length === 0) return DEFAULT_BUILT_AT;
+  return dates.sort(compareStrings).at(-1);
+}
+
+function summarizeTodo(todo) {
+  const summary = {
+    id: todo.id,
+    title: todo.title,
+    status: todo.status,
+  };
+  if (todo.project) summary.project = todo.project;
+  summary.tags = todo.tags;
+  summary.created_at = todo.created_at;
+  summary.completed_at = todo.completed_at;
+  return summary;
+}
+
+function summarizeProjects(todos) {
+  const projects = new Map();
+  for (const todo of todos) {
+    if (!todo.project) continue;
+    const current = projects.get(todo.project) || {
+      id: todo.project,
+      total_count: 0,
+      pending_count: 0,
+      done_count: 0,
+    };
+    current.total_count += 1;
+    if (todo.status === "done") current.done_count += 1;
+    if (todo.status === "pending") current.pending_count += 1;
+    projects.set(todo.project, current);
+  }
+  return [...projects.values()].sort((left, right) => compareStrings(left.id, right.id));
+}
+
+export function buildTodoBrowserData(wikiRoot) {
+  const queue = readTodoQueue(wikiRoot);
+  const todos = queue.todos.map(summarizeTodo);
+  const pending = todos.filter((todo) => todo.status === "pending");
+  const done = todos.filter((todo) => todo.status === "done");
+
+  return {
+    todos,
+    pending,
+    done,
+    projects: summarizeProjects(todos),
+    meta: {
+      built_at: deterministicBuiltAt(todos),
+      todo_count: todos.length,
+      pending_count: pending.length,
+      done_count: done.length,
+    },
+  };
+}

package/src/todo/queue.js

@@ -0,0 +1,159 @@
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { DEFAULT_BUILT_AT, validateTodoItem } from "./schema.js";
+
+function nowIso(options = {}) {
+  return options.now || new Date().toISOString();
+}
+
+function atomicWriteJson(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tmpFile = `${filePath}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+  fs.writeFileSync(tmpFile, JSON.stringify(data, null, 2));
+  fs.renameSync(tmpFile, filePath);
+}
+
+function result(success, payload = {}) {
+  return { success, ...payload };
+}
+
+function sortTodos(todos) {
+  return [...todos].sort((left, right) => `${left.created_at}:${left.id}`.localeCompare(`${right.created_at}:${right.id}`));
+}
+
+function createEmptyQueue() {
+  return { version: 1, todos: [], meta: { built_at: DEFAULT_BUILT_AT } };
+}
+
+function normalizeQueue(queue) {
+  const todos = [];
+  for (const todo of Array.isArray(queue?.todos) ? queue.todos : []) {
+    const validation = validateTodoItem(todo);
+    if (validation.valid) todos.push(validation.value);
+  }
+
+  return {
+    version: 1,
+    todos: sortTodos([...new Map(todos.map((todo) => [todo.id, todo])).values()]),
+    meta: { built_at: queue?.meta?.built_at || DEFAULT_BUILT_AT },
+  };
+}
+
+function writeQueue(wikiRoot, queue, options = {}) {
+  const normalized = normalizeQueue({ ...queue, meta: { built_at: nowIso(options) } });
+  atomicWriteJson(getTodoPaths(wikiRoot).todoFile, normalized);
+  return normalized;
+}
+
+function generateTodoId(existingIds) {
+  let id = `todo_${crypto.randomBytes(4).toString("hex")}`;
+  while (existingIds.has(id)) {
+    id = `todo_${crypto.randomBytes(4).toString("hex")}`;
+  }
+  return id;
+}
+
+function resolveTodo(queue, idOrTitle) {
+  const lookup = String(idOrTitle ?? "").trim();
+  if (!lookup) return result(false, { error: "TODO id or title is required" });
+
+  const idMatch = queue.todos.find((todo) => todo.id === lookup);
+  if (idMatch) return result(true, { todo: idMatch });
+
+  const titleMatches = queue.todos.filter((todo) => todo.title === lookup);
+  if (titleMatches.length === 1) return result(true, { todo: titleMatches[0] });
+  if (titleMatches.length > 1) return result(false, { error: `Multiple TODOs match title: ${lookup}` });
+  return result(false, { error: `TODO not found: ${lookup}` });
+}
+
+export function getTodoPaths(wikiRoot) {
+  const systemDir = path.join(wikiRoot, ".system");
+  return {
+    systemDir,
+    todoFile: path.join(systemDir, "todos.json"),
+  };
+}
+
+export function readTodoQueue(wikiRoot) {
+  const paths = getTodoPaths(wikiRoot);
+  if (!fs.existsSync(paths.todoFile)) return createEmptyQueue();
+
+  try {
+    return normalizeQueue(JSON.parse(fs.readFileSync(paths.todoFile, "utf-8")));
+  } catch {
+    return createEmptyQueue();
+  }
+}
+
+export function listTodos(wikiRoot, filters = {}) {
+  const queue = readTodoQueue(wikiRoot);
+  const project = String(filters.project ?? "").trim();
+  const todos = project
+    ? queue.todos.filter((todo) => todo.project === project)
+    : queue.todos;
+
+  return result(true, {
+    queue,
+    todos,
+    count: todos.length,
+    message: todos.length > 0
+      ? todos.map((todo) => `${todo.status === "done" ? "[x]" : "[ ]"} ${todo.id} ${todo.title}${todo.project ? ` (${todo.project})` : ""}`).join("\n")
+      : "No TODOs found.",
+  });
+}
+
+export function addTodo(wikiRoot, todo, options = {}) {
+  const queue = readTodoQueue(wikiRoot);
+  const createdAt = nowIso(options);
+  const validation = validateTodoItem({
+    ...todo,
+    id: todo.id || generateTodoId(new Set(queue.todos.map((item) => item.id))),
+    status: "pending",
+    created_at: todo.created_at || todo.createdAt || createdAt,
+    completed_at: null,
+  });
+
+  if (!validation.valid) return result(false, { error: validation.errors.join("; ") });
+
+  queue.todos = [...queue.todos.filter((item) => item.id !== validation.value.id), validation.value];
+  writeQueue(wikiRoot, queue, options);
+  return result(true, {
+    todo: validation.value,
+    message: `TODO added: ${validation.value.title}`,
+  });
+}
+
+export function markTodoDone(wikiRoot, idOrTitle, options = {}) {
+  const queue = readTodoQueue(wikiRoot);
+  const resolved = resolveTodo(queue, idOrTitle);
+  if (!resolved.success) return resolved;
+
+  const completedAt = resolved.todo.completed_at || nowIso(options);
+  const validation = validateTodoItem({
+    ...resolved.todo,
+    status: "done",
+    completed_at: completedAt,
+  });
+  if (!validation.valid) return result(false, { error: validation.errors.join("; ") });
+
+  queue.todos = queue.todos.map((todo) => todo.id === validation.value.id ? validation.value : todo);
+  writeQueue(wikiRoot, queue, options);
+  return result(true, {
+    todo: validation.value,
+    message: `TODO done: ${validation.value.title}`,
+  });
+}
+
+export function removeTodo(wikiRoot, idOrTitle, options = {}) {
+  const queue = readTodoQueue(wikiRoot);
+  const resolved = resolveTodo(queue, idOrTitle);
+  if (!resolved.success) return resolved;
+
+  queue.todos = queue.todos.filter((todo) => todo.id !== resolved.todo.id);
+  writeQueue(wikiRoot, queue, options);
+  return result(true, {
+    removed: resolved.todo,
+    message: `TODO removed: ${resolved.todo.title}`,
+  });
+}

package/src/todo/schema.js

@@ -0,0 +1,90 @@
+import { redactSecrets } from "../security.js";
+
+export const TODO_STATUSES = ["pending", "done"];
+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 normalizeId(value, label = "todo id") {
+  const id = normalizeScalar(value, 120).toLowerCase();
+  if (!/^todo_[a-z0-9][a-z0-9_-]{0,114}$/.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 normalizeTodoStatus(value) {
+  const status = normalizeScalar(value || "pending", 40).toLowerCase();
+  if (!TODO_STATUSES.includes(status)) {
+    throw new Error(`Invalid TODO status: ${value}`);
+  }
+  return status;
+}
+
+function normalizeProject(value) {
+  return normalizeScalar(value, 120);
+}
+
+function normalizeTimestamp(value, label, required = true) {
+  const timestamp = normalizeScalar(value, 80);
+  if (!timestamp && required) throw new Error(`${label} is required`);
+  if (timestamp && Number.isNaN(Date.parse(timestamp))) throw new Error(`Invalid ${label}: ${value}`);
+  return timestamp;
+}
+
+function validationResult(builder) {
+  try {
+    return { valid: true, value: builder(), errors: [] };
+  } catch (error) {
+    return { valid: false, value: null, errors: [error.message] };
+  }
+}
+
+export function validateTodoItem(input) {
+  return validationResult(() => {
+    if (!isRecord(input)) throw new Error("TODO item must be an object");
+    const status = normalizeTodoStatus(input.status);
+    const title = normalizeScalar(input.title, 220);
+    if (!title) throw new Error("TODO title is required");
+
+    const todo = {
+      id: normalizeId(input.id),
+      title,
+      status,
+    };
+
+    const project = normalizeProject(input.project);
+    if (project) todo.project = project;
+
+    todo.tags = normalizeStringList(input.tags, 80);
+    todo.created_at = normalizeTimestamp(input.created_at || input.createdAt || DEFAULT_BUILT_AT, "created_at");
+
+    if (status === "pending") {
+      todo.completed_at = null;
+    } else {
+      todo.completed_at = normalizeTimestamp(input.completed_at || input.completedAt, "completed_at");
+    }
+
+    return todo;
+  });
+}

package/src/utils/embedding-model.js

@@ -0,0 +1,111 @@
+import crypto from "node:crypto";
+
+const DEFAULT_DIMENSIONS = 384;
+const FEATURE_SALTS = ["0", "1", "2", "3", "4", "5"];
+
+function normalizeText(value) {
+  return String(value || "")
+    .normalize("NFKC")
+    .toLowerCase();
+}
+
+function addFeature(features, feature, weight) {
+  if (!feature) return;
+  features.set(feature, (features.get(feature) || 0) + weight);
+}
+
+function tokenize(text) {
+  const normalizedText = normalizeText(text);
+  const words = normalizedText
+    .replace(/[^\p{L}\p{N}\s]/gu, " ")
+    .split(/\s+/)
+    .filter((word) => word.length >= 2);
+
+  const features = new Map();
+  for (const word of words) {
+    addFeature(features, `w:${word}`, 1);
+    if (word.length > 3) {
+      for (let index = 0; index <= word.length - 3; index += 1) {
+        addFeature(features, `c:${word.slice(index, index + 3)}`, 0.25);
+      }
+    }
+  }
+
+  for (let index = 0; index < words.length - 1; index += 1) {
+    addFeature(features, `b:${words[index]} ${words[index + 1]}`, 0.75);
+  }
+
+  const koreanRuns = normalizedText.match(/[\uac00-\ud7af]+/g) || [];
+  for (const run of koreanRuns) {
+    for (let index = 0; index < run.length - 1; index += 1) {
+      addFeature(features, `ko:${run.slice(index, index + 2)}`, 0.8);
+    }
+  }
+
+  if (features.size === 0) {
+    addFeature(features, "empty", 1);
+  }
+
+  return features;
+}
+
+function projectFeature(vector, feature, weight) {
+  for (const salt of FEATURE_SALTS) {
+    const hash = crypto.createHash("sha256").update(`${salt}:${feature}`).digest();
+    const dimension = hash.readUInt32BE(0) % vector.length;
+    const sign = (hash.readUInt32BE(4) & 1) === 0 ? 1 : -1;
+    const magnitude = 0.5 + hash.readUInt16BE(8) / 0xffff;
+    vector[dimension] += sign * weight * magnitude;
+  }
+}
+
+function normalizeVector(vector) {
+  const norm = Math.sqrt(vector.reduce((sum, value) => sum + value * value, 0));
+  if (norm === 0) return vector;
+  return vector.map((value) => value / norm);
+}
+
+export class EmbeddingModel {
+  constructor(options = {}) {
+    this.dimensions = Number(options.dimensions) || DEFAULT_DIMENSIONS;
+    this.loaded = false;
+  }
+
+  async load() {
+    this.loaded = true;
+    return this;
+  }
+
+  isAvailable() {
+    return true;
+  }
+
+  async embed(text) {
+    if (!this.loaded) {
+      await this.load();
+    }
+
+    const vector = Array.from({ length: this.dimensions }, () => 0);
+    const features = tokenize(text);
+    for (const [feature, weight] of features.entries()) {
+      projectFeature(vector, feature, weight);
+    }
+
+    return normalizeVector(vector);
+  }
+
+  async embedBatch(texts) {
+    if (!Array.isArray(texts)) return [];
+    if (!this.loaded) {
+      await this.load();
+    }
+
+    const embeddings = [];
+    for (const text of texts) {
+      embeddings.push(await this.embed(text));
+    }
+    return embeddings;
+  }
+}
+
+export default EmbeddingModel;