@m16khb/llm-wiki 0.1.0

package/internal/wiki/vault_test.go

@@ -0,0 +1,188 @@
+package wiki
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestVaultInfoSearchReadAndLint(t *testing.T) {
+	root := t.TempDir()
+	writeTestPage(t, root, "20-wiki/concepts/llm-wiki-pattern.md", `---
+title: LLM Wiki Pattern
+type: concept
+status: active
+created: 2026-05-23
+updated: 2026-05-23
+tags: [llm, wiki]
+domain: agent-memory
+---
+
+# LLM Wiki Pattern
+
+A Karpathy-inspired wiki pattern related to [[andrej-karpathy]].
+`)
+	writeTestPage(t, root, "20-wiki/entities/andrej-karpathy.md", `---
+title: Andrej Karpathy
+type: entity
+status: active
+created: 2026-05-23
+updated: 2026-05-23
+tags: [llm]
+domain: people
+---
+
+# Andrej Karpathy
+`)
+	writeTestPage(t, root, "10-sources/karpathy-llm-wiki-gist.md", `---
+title: Karpathy LLM Wiki Gist
+type: source
+status: active
+created: 2026-05-23
+updated: 2026-05-23
+tags: [source]
+domain: primary-source
+---
+
+source card
+`)
+	writeTestPage(t, root, ".obsidian/ignored.md", `no frontmatter and should be ignored`)
+
+	v := newTestVault(t, root)
+	info, err := v.Info()
+	if err != nil {
+		t.Fatalf("Info() error = %v", err)
+	}
+	if info.MarkdownFiles != 3 || info.Sources != 1 || info.Concepts != 1 || info.Entities != 1 {
+		t.Fatalf("unexpected info: %+v", info)
+	}
+
+	results, err := v.Search(SearchOptions{Query: "karpathy", Limit: 2})
+	if err != nil {
+		t.Fatalf("Search() error = %v", err)
+	}
+	if len(results) == 0 || results[0].Score == 0 {
+		t.Fatalf("expected search hit, got %+v", results)
+	}
+
+	page, content, err := v.ReadPage("llm-wiki-pattern", 0)
+	if err != nil {
+		t.Fatalf("ReadPage() error = %v", err)
+	}
+	if page.Path != "20-wiki/concepts/llm-wiki-pattern.md" || !strings.Contains(content, "[[andrej-karpathy]]") {
+		t.Fatalf("unexpected read: page=%+v content=%q", page, content)
+	}
+
+	lint, err := v.Lint()
+	if err != nil {
+		t.Fatalf("Lint() error = %v", err)
+	}
+	if !lint.OK || len(lint.MissingFrontmatter) != 0 || len(lint.BrokenWikilinks) != 0 {
+		t.Fatalf("expected clean lint, got %+v", lint)
+	}
+}
+
+func TestLintReportsBrokenLinksAndDuplicateSlugWarning(t *testing.T) {
+	root := t.TempDir()
+	writeTestPage(t, root, "20-wiki/concepts/dup.md", testFrontmatter("Dup Concept", "concept")+"\n[[missing-page]]\n")
+	writeTestPage(t, root, "20-wiki/entities/dup.md", testFrontmatter("Dup Entity", "entity")+"\n")
+
+	lint, err := newTestVault(t, root).Lint()
+	if err != nil {
+		t.Fatalf("Lint() error = %v", err)
+	}
+	if lint.OK {
+		t.Fatalf("expected lint failure for broken link, got %+v", lint)
+	}
+	if len(lint.BrokenWikilinks) != 1 || !strings.Contains(lint.BrokenWikilinks[0], "missing-page") {
+		t.Fatalf("expected broken wikilink, got %+v", lint.BrokenWikilinks)
+	}
+	if len(lint.DuplicateSlugs) != 1 || len(lint.Warnings) != 1 {
+		t.Fatalf("expected duplicate slug warning, got %+v", lint)
+	}
+}
+
+func TestSafeJoinRejectsUnsafePaths(t *testing.T) {
+	v := newTestVault(t, t.TempDir())
+	for _, rel := range []string{"", "/tmp/file.md", "../escape.md", "20-wiki/../.obsidian/app.json", ".obsidian/app.json"} {
+		if _, err := v.SafeJoin(rel); err == nil {
+			t.Fatalf("SafeJoin(%q) expected error", rel)
+		}
+	}
+	if abs, err := v.SafeJoin("20-wiki/concepts/page.md"); err != nil || !strings.HasPrefix(abs, v.Root) {
+		t.Fatalf("SafeJoin allowed path = %q, %v", abs, err)
+	}
+}
+
+func TestCaptureWritesAllowedMarkdownAndRejectsProtectedFolders(t *testing.T) {
+	v := newTestVault(t, t.TempDir())
+	v.Now = func() time.Time { return time.Date(2026, 5, 23, 12, 0, 0, 0, time.UTC) }
+
+	result, err := v.Capture(CaptureInput{
+		Title:  "Captured Note",
+		Body:   "Captured body.",
+		Type:   "concept",
+		Tags:   []string{"agent", "wiki"},
+		Folder: "20-wiki/concepts",
+		Slug:   "captured-note",
+	})
+	if err != nil {
+		t.Fatalf("Capture() error = %v", err)
+	}
+	if result.Path != "20-wiki/concepts/captured-note.md" || !result.Created || result.Overwrote {
+		t.Fatalf("unexpected capture result: %+v", result)
+	}
+	data, err := os.ReadFile(filepath.Join(v.Root, filepath.FromSlash(result.Path)))
+	if err != nil {
+		t.Fatalf("read captured file: %v", err)
+	}
+	content := string(data)
+	for _, want := range []string{`title: "Captured Note"`, "created: 2026-05-23", "tags: [agent, wiki]", "## Changelog"} {
+		if !strings.Contains(content, want) {
+			t.Fatalf("captured content missing %q:\n%s", want, content)
+		}
+	}
+
+	if _, err := v.Capture(CaptureInput{Title: "Dup", Body: "body", Folder: "20-wiki/concepts", Slug: "captured-note"}); err == nil {
+		t.Fatalf("expected duplicate capture to fail without overwrite")
+	}
+	for _, folder := range []string{"10-sources", ".obsidian", "_archive", "../20-wiki/concepts"} {
+		if _, err := v.Capture(CaptureInput{Title: "Bad", Body: "body", Folder: folder, Slug: "bad"}); err == nil {
+			t.Fatalf("Capture folder %q expected error", folder)
+		}
+	}
+}
+
+func newTestVault(t *testing.T, root string) *Vault {
+	t.Helper()
+	v, err := New(root)
+	if err != nil {
+		t.Fatalf("New(%q) error = %v", root, err)
+	}
+	return v
+}
+
+func writeTestPage(t *testing.T, root, rel, content string) {
+	t.Helper()
+	abs := filepath.Join(root, filepath.FromSlash(rel))
+	if err := os.MkdirAll(filepath.Dir(abs), 0o755); err != nil {
+		t.Fatalf("mkdir %s: %v", rel, err)
+	}
+	if err := os.WriteFile(abs, []byte(content), 0o644); err != nil {
+		t.Fatalf("write %s: %v", rel, err)
+	}
+}
+
+func testFrontmatter(title, typ string) string {
+	return "---\n" +
+		"title: " + title + "\n" +
+		"type: " + typ + "\n" +
+		"status: active\n" +
+		"created: 2026-05-23\n" +
+		"updated: 2026-05-23\n" +
+		"tags: []\n" +
+		"domain: test\n" +
+		"---\n"
+}

package/npm/bin/llm-wiki.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../lib/runner').run();

package/npm/lib/runner.js

@@ -0,0 +1,167 @@
+const childProcess = require('node:child_process');
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const SIGNAL_EXIT_CODES = {
+  SIGINT: 130,
+  SIGTERM: 143,
+};
+
+function executableName(platform = process.platform) {
+  return platform === 'win32' ? 'llm-wiki.exe' : 'llm-wiki';
+}
+
+function isExecutable(file) {
+  try {
+    const stat = fs.statSync(file);
+    return stat.isFile();
+  } catch (err) {
+    if (err && err.code === 'ENOENT') return false;
+    throw err;
+  }
+}
+
+function findBundledBinary(packageRoot, platform = process.platform) {
+  const candidate = path.join(packageRoot, 'bin', executableName(platform));
+  return isExecutable(candidate) ? candidate : '';
+}
+
+function readPackageVersion(packageRoot) {
+  try {
+    const data = fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8');
+    const pkg = JSON.parse(data);
+    return typeof pkg.version === 'string' && pkg.version ? pkg.version : '0.0.0';
+  } catch (_err) {
+    return '0.0.0';
+  }
+}
+
+function hashFile(hash, root, file) {
+  let stat;
+  try {
+    stat = fs.statSync(file);
+  } catch (err) {
+    if (err && err.code === 'ENOENT') return;
+    throw err;
+  }
+  if (stat.isDirectory()) {
+    const entries = fs.readdirSync(file).sort();
+    for (const entry of entries) {
+      hashFile(hash, root, path.join(file, entry));
+    }
+    return;
+  }
+  const isBuildInput = file.endsWith('.go') || ['go.mod', 'go.sum', 'package.json'].includes(path.basename(file));
+  if (!stat.isFile() || !isBuildInput) {
+    return;
+  }
+  hash.update(path.relative(root, file));
+  hash.update('\0');
+  hash.update(String(stat.size));
+  hash.update('\0');
+  hash.update(String(Math.trunc(stat.mtimeMs)));
+  hash.update('\0');
+}
+
+function sourceFingerprint(packageRoot) {
+  const hash = crypto.createHash('sha256');
+  for (const entry of ['go.mod', 'go.sum', 'package.json', 'cmd', 'internal']) {
+    hashFile(hash, packageRoot, path.join(packageRoot, entry));
+  }
+  return hash.digest('hex').slice(0, 16);
+}
+
+function defaultCacheRoot(env = process.env) {
+  if (env.LLM_WIKI_NPM_CACHE_DIR) return env.LLM_WIKI_NPM_CACHE_DIR;
+  if (env.XDG_CACHE_HOME) return path.join(env.XDG_CACHE_HOME, 'llm-wiki', 'npm-wrapper');
+  const home = os.homedir();
+  if (home) return path.join(home, '.cache', 'llm-wiki', 'npm-wrapper');
+  return path.join(os.tmpdir(), 'llm-wiki', 'npm-wrapper');
+}
+
+function cacheBinaryPath(packageRoot, env = process.env, platform = process.platform, arch = process.arch) {
+  const version = readPackageVersion(packageRoot);
+  const fingerprint = sourceFingerprint(packageRoot);
+  const filename = `llm-wiki-${version}-${platform}-${arch}-${fingerprint}${platform === 'win32' ? '.exe' : ''}`;
+  return path.join(defaultCacheRoot(env), filename);
+}
+
+function buildBinary(packageRoot, output, env = process.env) {
+  fs.mkdirSync(path.dirname(output), { recursive: true });
+  const result = childProcess.spawnSync('go', ['build', '-o', output, './cmd/llm-wiki'], {
+    cwd: packageRoot,
+    env,
+    stdio: ['ignore', 'ignore', 'inherit'],
+  });
+  if (result.error) {
+    throw new Error(`Go toolchain is required to build llm-wiki for npx: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    throw new Error(`go build failed with exit code ${result.status}`);
+  }
+  if (!isExecutable(output)) {
+    throw new Error(`go build did not create expected binary: ${output}`);
+  }
+  return output;
+}
+
+function ensureBinary(options = {}) {
+  const env = options.env || process.env;
+  const packageRoot = options.packageRoot || env.LLM_WIKI_NPM_PACKAGE_ROOT || path.resolve(__dirname, '..', '..');
+  const bundled = findBundledBinary(packageRoot);
+  if (bundled) return bundled;
+
+  const cached = cacheBinaryPath(packageRoot, env);
+  if (isExecutable(cached) && env.LLM_WIKI_NPM_REBUILD !== '1') return cached;
+  return buildBinary(packageRoot, cached, env);
+}
+
+function exitCodeForSignal(signal) {
+  return SIGNAL_EXIT_CODES[signal] || 1;
+}
+
+function run(argv = process.argv.slice(2), options = {}) {
+  const env = options.env || process.env;
+  let binary;
+  try {
+    binary = ensureBinary({ env, packageRoot: options.packageRoot });
+  } catch (err) {
+    console.error(`llm-wiki npm wrapper: ${err.message}`);
+    process.exit(1);
+  }
+
+  const child = childProcess.spawn(binary, argv, {
+    env,
+    stdio: 'inherit',
+  });
+
+  let childExited = false;
+  child.on('error', (err) => {
+    console.error(`llm-wiki npm wrapper: failed to run ${binary}: ${err.message}`);
+    process.exit(1);
+  });
+  child.on('exit', (code, signal) => {
+    childExited = true;
+    if (signal) {
+      process.exit(exitCodeForSignal(signal));
+    }
+    process.exit(code === null ? 1 : code);
+  });
+
+  for (const signal of Object.keys(SIGNAL_EXIT_CODES)) {
+    process.on(signal, () => {
+      if (!childExited) child.kill(signal);
+    });
+  }
+}
+
+module.exports = {
+  cacheBinaryPath,
+  ensureBinary,
+  executableName,
+  findBundledBinary,
+  run,
+  sourceFingerprint,
+};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@m16khb/llm-wiki",
+  "version": "0.1.0",
+  "description": "npx wrapper for the llm-wiki Go MCP server and CLI",
+  "bin": {
+    "llm-wiki": "npm/bin/llm-wiki.js"
+  },
+  "files": [
+    "cmd/",
+    "internal/",
+    "npm/bin/",
+    "npm/lib/",
+    "go.mod",
+    "go.sum",
+    "README.md"
+  ],
+  "scripts": {
+    "test:npm": "node --test npm/test/*.test.js",
+    "build:go": "go build -o bin/llm-wiki ./cmd/llm-wiki"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  }
+}