oh-my-llmwikimode 1.0.0

package/scripts/install-llmwiki.ps1

@@ -0,0 +1,229 @@
+param(
+  [string]$WikiRoot = "~/Documents/llm-wiki",
+  [string]$ConfigPath = ""
+)
+
+$ErrorActionPreference = "Stop"
+
+$PluginName = "oh-my-llmwikimode"
+
+function Get-HomePath {
+  if (-not [string]::IsNullOrWhiteSpace($env:USERPROFILE)) {
+    return $env:USERPROFILE
+  }
+
+  return $HOME
+}
+
+function Expand-UserPath {
+  param([string]$InputPath)
+
+  if ([string]::IsNullOrWhiteSpace($InputPath)) {
+    return $InputPath
+  }
+
+  $homePath = Get-HomePath
+  if ($InputPath -eq "~") {
+    return $homePath
+  }
+
+  if ($InputPath.StartsWith("~/") -or $InputPath.StartsWith("~\")) {
+    return Join-Path $homePath $InputPath.Substring(2)
+  }
+
+  return [System.IO.Path]::GetFullPath($InputPath)
+}
+
+function Get-DefaultOpenCodeConfigDir {
+  return Join-Path (Get-HomePath) ".config\opencode"
+}
+
+function ConvertTo-PlainObject {
+  param($InputObject)
+
+  if ($null -eq $InputObject) {
+    return $null
+  }
+
+  if ($InputObject -is [System.Management.Automation.PSCustomObject]) {
+    $result = [ordered]@{}
+    foreach ($property in $InputObject.PSObject.Properties) {
+      $result[$property.Name] = ConvertTo-PlainObject $property.Value
+    }
+    return $result
+  }
+
+  if (($InputObject -is [System.Collections.IEnumerable]) -and -not ($InputObject -is [string])) {
+    $items = @()
+    foreach ($item in $InputObject) {
+      $items += ,(ConvertTo-PlainObject $item)
+    }
+    return ,$items
+  }
+
+  return $InputObject
+}
+
+function Read-OpenCodeConfig {
+  param([string]$TargetConfigPath)
+
+  if (-not (Test-Path -LiteralPath $TargetConfigPath)) {
+    return [ordered]@{}
+  }
+
+  $rawJson = Get-Content -LiteralPath $TargetConfigPath -Raw -Encoding UTF8
+  if ([string]::IsNullOrWhiteSpace($rawJson)) {
+    return [ordered]@{}
+  }
+
+  try {
+    $parsed = $rawJson | ConvertFrom-Json
+    $plain = ConvertTo-PlainObject $parsed
+    if (-not ($plain -is [System.Collections.IDictionary])) {
+      throw "opencode.json root must be a JSON object."
+    }
+    return $plain
+  } catch {
+    throw "Could not parse $TargetConfigPath. Fix the JSON first; no changes were written. $($_.Exception.Message)"
+  }
+}
+
+function New-LlmWikiPluginEntry {
+  param([string]$ConfiguredWikiRoot)
+
+  return ,@(
+    $PluginName,
+    [ordered]@{
+      wikiRoot = $ConfiguredWikiRoot
+      autoMemoryEnabled = $true
+      autoSearchEnabled = $true
+    }
+  )
+}
+
+function Test-LlmWikiPluginEntry {
+  param($Entry)
+
+  $items = @($Entry)
+  return ($items.Count -ge 1 -and [string]$items[0] -eq $PluginName)
+}
+
+function Add-OrUpdatePluginEntry {
+  param(
+    [System.Collections.IDictionary]$Config,
+    [string]$ConfiguredWikiRoot
+  )
+
+  $pluginEntry = New-LlmWikiPluginEntry $ConfiguredWikiRoot
+  $existingPlugins = @()
+  if ($Config.Contains("plugin") -and $null -ne $Config["plugin"]) {
+    foreach ($entry in @($Config["plugin"])) {
+      $existingPlugins += ,$entry
+    }
+  }
+
+  $updatedPlugins = @()
+  $found = $false
+  foreach ($entry in $existingPlugins) {
+    if (Test-LlmWikiPluginEntry $entry) {
+      $updatedPlugins += ,$pluginEntry
+      $found = $true
+    } else {
+      $updatedPlugins += ,$entry
+    }
+  }
+
+  if (-not $found) {
+    $updatedPlugins += ,$pluginEntry
+  }
+
+  $Config["plugin"] = @($updatedPlugins)
+  return $Config
+}
+
+function Get-PluginSnippetJson {
+  param([string]$ConfiguredWikiRoot)
+
+  $snippet = [ordered]@{
+    plugin = @(
+      (New-LlmWikiPluginEntry $ConfiguredWikiRoot)
+    )
+  }
+  return ($snippet | ConvertTo-Json -Depth 20)
+}
+
+function Ensure-WikiDirectories {
+  param([string]$ResolvedWikiRoot)
+
+  $directories = @(
+    $ResolvedWikiRoot,
+    (Join-Path $ResolvedWikiRoot "inbox"),
+    (Join-Path $ResolvedWikiRoot "problems"),
+    (Join-Path (Join-Path $ResolvedWikiRoot "editorial") "lessons"),
+    (Join-Path $ResolvedWikiRoot "raw"),
+    (Join-Path $ResolvedWikiRoot ".system")
+  )
+
+  foreach ($directory in $directories) {
+    if (-not (Test-Path -LiteralPath $directory)) {
+      New-Item -ItemType Directory -Path $directory -Force | Out-Null
+    }
+  }
+}
+
+function Write-NextSteps {
+  param(
+    [string]$ResolvedWikiRoot,
+    [string]$TargetConfigPath
+  )
+
+  Write-Host ""
+  Write-Host "LLM Wiki installation complete." -ForegroundColor Green
+  Write-Host "Wiki root: $ResolvedWikiRoot"
+  Write-Host "OpenCode config: $TargetConfigPath"
+  Write-Host ""
+  Write-Host "Next steps:"
+  Write-Host "1. Restart OpenCode."
+  Write-Host "2. Ask OpenCode to check your wiki status."
+  Write-Host ('3. Optional CLI check: npx llmwiki lint --wiki-root "{0}"' -f $WikiRoot)
+}
+
+$resolvedWikiRoot = Expand-UserPath $WikiRoot
+$configDir = Get-DefaultOpenCodeConfigDir
+if (-not [string]::IsNullOrWhiteSpace($ConfigPath)) {
+  $resolvedConfigPath = Expand-UserPath $ConfigPath
+  $configDir = Split-Path -Parent $resolvedConfigPath
+} else {
+  $resolvedConfigPath = Join-Path $configDir "opencode.json"
+}
+
+Ensure-WikiDirectories $resolvedWikiRoot
+
+if (-not (Test-Path -LiteralPath $configDir)) {
+  New-Item -ItemType Directory -Path $configDir -Force | Out-Null
+}
+
+$configExists = Test-Path -LiteralPath $resolvedConfigPath
+if ($configExists) {
+  Write-Host "Existing OpenCode config found: $resolvedConfigPath"
+  Write-Host "A timestamped backup will be created before any change."
+  $answer = Read-Host "Continue updating opencode.json? [y/N]"
+  if ($answer -notmatch "(?i)^(y|yes)$") {
+    Write-Host "Config not modified. Add this snippet manually if you want to finish setup:"
+    Write-Host (Get-PluginSnippetJson $WikiRoot)
+    exit 0
+  }
+
+  $timestamp = Get-Date -Format "yyyyMMdd-HHmmss"
+  $backupPath = "$resolvedConfigPath.bak.$timestamp"
+  Copy-Item -LiteralPath $resolvedConfigPath -Destination $backupPath -Force
+  Write-Host "Backup written: $backupPath"
+}
+
+$config = Read-OpenCodeConfig $resolvedConfigPath
+$config = Add-OrUpdatePluginEntry $config $WikiRoot
+$configJson = $config | ConvertTo-Json -Depth 20
+$utf8NoBom = New-Object System.Text.UTF8Encoding($false)
+[System.IO.File]::WriteAllText($resolvedConfigPath, $configJson + [Environment]::NewLine, $utf8NoBom)
+
+Write-NextSteps -ResolvedWikiRoot $resolvedWikiRoot -TargetConfigPath $resolvedConfigPath

package/src/config.js

@@ -0,0 +1,74 @@
+/**
+ * Configuration and path resolution for oh-my-llmwikimode
+ */
+
+import os from "node:os";
+import path from "node:path";
+
+/**
+ * Expand `~` in a path to the user's home directory.
+ *
+ * @param {string} inputPath
+ * @returns {string}
+ */
+export function expandHome(inputPath) {
+  if (!inputPath || typeof inputPath !== "string") {
+    return inputPath;
+  }
+
+  if (inputPath.startsWith("~/")) {
+    return path.join(os.homedir(), inputPath.slice(2));
+  }
+
+  if (inputPath === "~") {
+    return os.homedir();
+  }
+
+  return inputPath;
+}
+
+/**
+ * Resolve wiki root path with precedence:
+ * 1. Explicit plugin option `wikiRoot`
+ * 2. Environment variable `LLMWIKIMODE_WIKI_ROOT`
+ * 3. Default `~/Documents/llm-wiki`
+ *
+ * @param {object} options - Plugin options from opencode.json
+ * @returns {string} - Resolved absolute path
+ */
+export function resolveWikiRoot(options = {}) {
+  const fromOption = options.wikiRoot;
+  const fromEnv = process.env.LLMWIKIMODE_WIKI_ROOT;
+  const defaultPath = "~/Documents/llm-wiki";
+
+  const rawPath = fromOption || fromEnv || defaultPath;
+  return path.resolve(expandHome(rawPath));
+}
+
+/**
+ * Resolve state directory path.
+ * Default: `~/.config/opencode/.llmwikimode/`
+ *
+ * @returns {string} - Resolved absolute path
+ */
+export function resolveStateDir() {
+  return path.resolve(expandHome("~/.config/opencode/.llmwikimode"));
+}
+
+/**
+ * Get full configuration object.
+ *
+ * @param {object} options - Plugin options from opencode.json
+ * @returns {object}
+ */
+export function getConfig(options = {}) {
+  return {
+    wikiRoot: resolveWikiRoot(options),
+    stateDir: resolveStateDir(),
+    autoMemoryEnabled: options.autoMemoryEnabled !== false,
+    verboseAutoMemory: options.verboseAutoMemory === true,
+    autoSearchEnabled: options.autoSearchEnabled !== false,
+    contextBudget: options.contextBudget || 2500,
+    maxEntries: options.maxEntries || 3,
+  };
+}

package/src/curator/browser-data.js

@@ -0,0 +1,134 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getCuratorPaths, readCuratorQueue } from "./queue.js";
+import { validateConsolidationProposal, validateLessonCandidateArtifact } from "./schema.js";
+
+function compareStrings(left, right) {
+  return String(left ?? "").localeCompare(String(right ?? ""));
+}
+
+function summarizeCard(card) {
+  return {
+    id: card.id,
+    kind: card.kind,
+    title: card.title,
+    status: card.status,
+    review_required: card.review_required,
+    artifact_path: card.artifact_path,
+    source_paths: card.source_paths,
+    scoring_hints: card.scoring_hints,
+    created_at: card.created_at,
+    updated_at: card.updated_at,
+  };
+}
+
+function summarizeCandidate(candidate, artifactPath) {
+  return {
+    id: candidate.id,
+    title: candidate.title,
+    status: candidate.status,
+    review_required: candidate.review_required,
+    artifact_path: artifactPath,
+    source_paths: candidate.source_refs.map((ref) => ref.path),
+    related_paths: candidate.related_refs.map((ref) => ref.path),
+    proposed_title: candidate.proposed_lesson.title,
+    proposed_tags: candidate.proposed_lesson.tags,
+    scoring_hints: candidate.scoring_hints,
+    created_at: candidate.created_at,
+    updated_at: candidate.updated_at,
+  };
+}
+
+function summarizeProposal(proposal, artifactPath) {
+  return {
+    id: proposal.id,
+    title: proposal.title,
+    status: proposal.status,
+    review_required: proposal.review_required,
+    artifact_path: artifactPath,
+    entry_paths: proposal.entry_refs.map((ref) => ref.path),
+    rationale: proposal.rationale,
+    proposed_actions: proposal.proposed_actions,
+    scoring_hints: proposal.scoring_hints,
+    created_at: proposal.created_at,
+    updated_at: proposal.updated_at,
+  };
+}
+
+function readJsonArtifacts(directory, relativePrefix, validator, summarizer) {
+  if (!fs.existsSync(directory)) return [];
+  return fs.readdirSync(directory)
+    .filter((fileName) => fileName.endsWith(".json"))
+    .sort(compareStrings)
+    .flatMap((fileName) => {
+      const filePath = path.join(directory, fileName);
+      const artifactPath = `${relativePrefix}/${fileName}`;
+      try {
+        const validation = validator(JSON.parse(fs.readFileSync(filePath, "utf-8")));
+        if (!validation.valid) return [];
+        return [summarizer(validation.value, artifactPath)];
+      } catch {
+        return [];
+      }
+    });
+}
+
+function readAuditSummary(wikiRoot) {
+  const paths = getCuratorPaths(wikiRoot);
+  const actionCounts = {};
+  let auditCount = 0;
+  let lastRecord = null;
+
+  if (fs.existsSync(paths.auditFile)) {
+    for (const line of fs.readFileSync(paths.auditFile, "utf-8").split(/\r?\n/).filter(Boolean)) {
+      try {
+        const record = JSON.parse(line);
+        const action = String(record.action || "unknown");
+        actionCounts[action] = (actionCounts[action] || 0) + 1;
+        auditCount += 1;
+        lastRecord = record;
+      } catch {
+        actionCounts.malformed = (actionCounts.malformed || 0) + 1;
+        auditCount += 1;
+      }
+    }
+  }
+
+  return {
+    audit_count: auditCount,
+    action_counts: Object.fromEntries(Object.entries(actionCounts).sort(([left], [right]) => compareStrings(left, right))),
+    last_action: lastRecord?.action || "",
+    last_actor: lastRecord?.actor || "",
+    last_timestamp: lastRecord?.timestamp || "",
+  };
+}
+
+export function buildCuratorBrowserData(wikiRoot) {
+  const paths = getCuratorPaths(wikiRoot);
+  const queue = readCuratorQueue(wikiRoot);
+  const queueCards = queue.cards.map(summarizeCard);
+  const lessonCandidates = readJsonArtifacts(
+    paths.candidatesDir,
+    ".system/curator/lesson-candidates",
+    validateLessonCandidateArtifact,
+    summarizeCandidate
+  );
+  const consolidationProposals = readJsonArtifacts(
+    paths.proposalsDir,
+    ".system/curator/consolidation-proposals",
+    validateConsolidationProposal,
+    summarizeProposal
+  );
+
+  return {
+    queue_cards: queueCards,
+    lesson_candidates: lessonCandidates,
+    consolidation_proposals: consolidationProposals,
+    audit_summary: {
+      ...readAuditSummary(wikiRoot),
+      card_count: queueCards.length,
+      lesson_candidate_count: lessonCandidates.length,
+      consolidation_proposal_count: consolidationProposals.length,
+    },
+  };
+}