@m16khb/llm-wiki 0.1.0

package/internal/daemon/server.go

@@ -0,0 +1,133 @@
+package daemon
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"log"
+	"net/http"
+	"time"
+
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+
+	"github.com/m16khb/llm-wiki/internal/mcpserver"
+	"github.com/m16khb/llm-wiki/internal/service"
+	"github.com/m16khb/llm-wiki/internal/store"
+)
+
+// Config configures the long-running daemon process.
+type Config struct {
+	VaultRoot string
+	DBPath    string
+	Addr      string
+}
+
+// Server owns the singleton daemon service and HTTP MCP endpoint.
+type Server struct {
+	Service *service.Service
+	Addr    string
+	DBPath  string
+	Lock    *Lock
+	HTTP    *http.Server
+}
+
+func New(cfg Config) (*Server, error) {
+	if cfg.Addr == "" {
+		cfg.Addr = "127.0.0.1:39233"
+	}
+	dbPath := cfg.DBPath
+	if dbPath == "" {
+		dbPath = store.DefaultPath()
+	}
+	lock, err := AcquireLock(dbPath + ".lock")
+	if err != nil {
+		return nil, err
+	}
+	svc, err := service.New(service.Config{VaultRoot: cfg.VaultRoot, DBPath: dbPath})
+	if err != nil {
+		lock.Close()
+		return nil, err
+	}
+	mux := NewHandler(svc)
+	httpServer := &http.Server{Addr: cfg.Addr, Handler: mux, ReadHeaderTimeout: 10 * time.Second}
+	return &Server{Service: svc, Addr: cfg.Addr, DBPath: svc.DBPath(), Lock: lock, HTTP: httpServer}, nil
+}
+
+func (s *Server) Serve(ctx context.Context) error {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	errCh := make(chan error, 1)
+	go func() {
+		log.Printf("llm-wiki daemon listening on http://%s/mcp vault=%s db=%s", s.Addr, s.Service.VaultRoot(), s.DBPath)
+		errCh <- s.HTTP.ListenAndServe()
+	}()
+	select {
+	case <-ctx.Done():
+		shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		_ = s.HTTP.Shutdown(shutdownCtx)
+		<-errCh
+		return ctx.Err()
+	case err := <-errCh:
+		if errors.Is(err, http.ErrServerClosed) {
+			return nil
+		}
+		return err
+	}
+}
+
+func (s *Server) Close() error {
+	var err error
+	if s.HTTP != nil {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		err = s.HTTP.Shutdown(ctx)
+		cancel()
+	}
+	if s.Service != nil {
+		if closeErr := s.Service.Close(); err == nil {
+			err = closeErr
+		}
+	}
+	if s.Lock != nil {
+		if lockErr := s.Lock.Close(); err == nil {
+			err = lockErr
+		}
+	}
+	return err
+}
+
+func NewHandler(svc *service.Service) http.Handler {
+	server := mcpserver.NewWithBackend(svc)
+	mcpHandler := mcp.NewStreamableHTTPHandler(func(r *http.Request) *mcp.Server { return server }, &mcp.StreamableHTTPOptions{JSONResponse: true, SessionTimeout: 30 * time.Minute})
+	mux := http.NewServeMux()
+	mux.Handle("/mcp", mcpHandler)
+	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodGet {
+			http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+			return
+		}
+		info, err := svc.Info()
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(map[string]any{"ok": true, "vault": svc.VaultRoot(), "db": svc.DBPath(), "markdown_files": info.MarkdownFiles})
+	})
+	mux.HandleFunc("/jobs", func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodGet {
+			http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+			return
+		}
+		jobs, err := svc.RecentJobs(r.Context(), 20)
+		if err != nil {
+			http.Error(w, fmt.Sprintf("jobs: %v", err), http.StatusInternalServerError)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(jobs)
+	})
+	return mux
+}

package/internal/mcpserver/server.go

@@ -0,0 +1,162 @@
+package mcpserver
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+
+	"github.com/m16khb/llm-wiki/internal/service"
+	"github.com/m16khb/llm-wiki/internal/wiki"
+)
+
+const Version = "0.1.0"
+
+// Config configures the MCP server.
+type Config struct {
+	VaultRoot string
+	DBPath    string
+}
+
+type emptyInput struct{}
+
+type infoOutput struct {
+	Info wiki.Info `json:"info"`
+}
+
+type searchInput struct {
+	Query          string   `json:"query" jsonschema:"keywords to search for"`
+	Limit          int      `json:"limit,omitempty" jsonschema:"maximum results, default 10, max 50"`
+	Roots          []string `json:"roots,omitempty" jsonschema:"optional vault-relative folders such as 20-wiki or 10-sources"`
+	IncludeArchive bool     `json:"include_archive,omitempty" jsonschema:"include _archive pages when true"`
+}
+
+type searchOutput struct {
+	Query   string              `json:"query"`
+	Results []wiki.SearchResult `json:"results"`
+}
+
+type readInput struct {
+	Page     string `json:"page" jsonschema:"wikilink slug or vault-relative markdown path"`
+	MaxBytes int    `json:"max_bytes,omitempty" jsonschema:"optional maximum bytes to return"`
+}
+
+type readOutput struct {
+	Page    wiki.Page `json:"page"`
+	Content string    `json:"content"`
+}
+
+type lintOutput struct {
+	Result wiki.LintResult `json:"result"`
+}
+
+type captureOutput struct {
+	Result wiki.CaptureResult `json:"result"`
+}
+
+// Backend is the shared service surface used by MCP tools.
+type Backend interface {
+	Info() (wiki.Info, error)
+	Search(wiki.SearchOptions) ([]wiki.SearchResult, error)
+	ReadPage(string, int) (wiki.Page, string, error)
+	Lint() (wiki.LintResult, error)
+	CaptureContext(context.Context, wiki.CaptureInput) (wiki.CaptureResult, error)
+}
+
+// New builds an MCP server exposing Obsidian-backed wiki tools backed by the
+// SQLite queue service.
+func New(cfg Config) (*mcp.Server, error) {
+	backend, err := service.New(service.Config{VaultRoot: cfg.VaultRoot, DBPath: cfg.DBPath})
+	if err != nil {
+		return nil, err
+	}
+	return NewWithBackend(backend), nil
+}
+
+// NewWithBackend builds an MCP server around an existing daemon/service backend.
+func NewWithBackend(backend Backend) *mcp.Server {
+	server := mcp.NewServer(&mcp.Implementation{Name: "llm-wiki", Version: Version}, nil)
+	registerTools(server, backend)
+	return server
+}
+
+func registerTools(server *mcp.Server, backend Backend) {
+	closedWorld := false
+	addReadOnly := func(name, title, description string, handler any) {
+		switch h := handler.(type) {
+		case func(context.Context, *mcp.CallToolRequest, emptyInput) (*mcp.CallToolResult, infoOutput, error):
+			mcp.AddTool(server, &mcp.Tool{Name: name, Title: title, Description: description, Annotations: &mcp.ToolAnnotations{Title: title, ReadOnlyHint: true, OpenWorldHint: &closedWorld}}, h)
+		case func(context.Context, *mcp.CallToolRequest, searchInput) (*mcp.CallToolResult, searchOutput, error):
+			mcp.AddTool(server, &mcp.Tool{Name: name, Title: title, Description: description, Annotations: &mcp.ToolAnnotations{Title: title, ReadOnlyHint: true, OpenWorldHint: &closedWorld}}, h)
+		case func(context.Context, *mcp.CallToolRequest, readInput) (*mcp.CallToolResult, readOutput, error):
+			mcp.AddTool(server, &mcp.Tool{Name: name, Title: title, Description: description, Annotations: &mcp.ToolAnnotations{Title: title, ReadOnlyHint: true, OpenWorldHint: &closedWorld}}, h)
+		case func(context.Context, *mcp.CallToolRequest, emptyInput) (*mcp.CallToolResult, lintOutput, error):
+			mcp.AddTool(server, &mcp.Tool{Name: name, Title: title, Description: description, Annotations: &mcp.ToolAnnotations{Title: title, ReadOnlyHint: true, OpenWorldHint: &closedWorld}}, h)
+		default:
+			panic("unsupported handler type")
+		}
+	}
+
+	addReadOnly("wiki_info", "Wiki info", "Summarize the configured Obsidian LLM Wiki vault.",
+		func(ctx context.Context, req *mcp.CallToolRequest, in emptyInput) (*mcp.CallToolResult, infoOutput, error) {
+			info, err := backend.Info()
+			if err != nil {
+				return nil, infoOutput{}, err
+			}
+			return textResult(info), infoOutput{Info: info}, nil
+		})
+
+	addReadOnly("wiki_search", "Wiki search", "Search Markdown pages in the LLM Wiki by keyword.",
+		func(ctx context.Context, req *mcp.CallToolRequest, in searchInput) (*mcp.CallToolResult, searchOutput, error) {
+			results, err := backend.Search(wiki.SearchOptions{Query: in.Query, Limit: in.Limit, Roots: in.Roots, IncludeArchive: in.IncludeArchive})
+			if err != nil {
+				return nil, searchOutput{}, err
+			}
+			out := searchOutput{Query: in.Query, Results: results}
+			return textResult(out), out, nil
+		})
+
+	addReadOnly("wiki_read", "Wiki read", "Read a wiki page by wikilink slug or vault-relative Markdown path.",
+		func(ctx context.Context, req *mcp.CallToolRequest, in readInput) (*mcp.CallToolResult, readOutput, error) {
+			page, content, err := backend.ReadPage(in.Page, in.MaxBytes)
+			if err != nil {
+				return nil, readOutput{}, err
+			}
+			out := readOutput{Page: page, Content: content}
+			return &mcp.CallToolResult{Content: []mcp.Content{&mcp.TextContent{Text: content}}}, out, nil
+		})
+
+	addReadOnly("wiki_lint", "Wiki lint", "Run structural lint checks for frontmatter, duplicate slugs, and broken wikilinks.",
+		func(ctx context.Context, req *mcp.CallToolRequest, in emptyInput) (*mcp.CallToolResult, lintOutput, error) {
+			result, err := backend.Lint()
+			if err != nil {
+				return nil, lintOutput{}, err
+			}
+			out := lintOutput{Result: result}
+			return textResult(out), out, nil
+		})
+
+	destructive := false
+	mcp.AddTool(server, &mcp.Tool{
+		Name:        "wiki_capture",
+		Title:       "Wiki capture",
+		Description: "Create or overwrite a curated Markdown note in allowed LLM Wiki folders. Does not write 10-sources or .obsidian.",
+		Annotations: &mcp.ToolAnnotations{Title: "Wiki capture", ReadOnlyHint: false, DestructiveHint: &destructive, IdempotentHint: false, OpenWorldHint: &closedWorld},
+	}, func(ctx context.Context, req *mcp.CallToolRequest, in wiki.CaptureInput) (*mcp.CallToolResult, captureOutput, error) {
+		result, err := backend.CaptureContext(ctx, in)
+		if err != nil {
+			return nil, captureOutput{}, err
+		}
+		out := captureOutput{Result: result}
+		return textResult(out), out, nil
+	})
+}
+
+func textResult(v any) *mcp.CallToolResult {
+	data, err := json.MarshalIndent(v, "", "  ")
+	if err != nil {
+		data = []byte(fmt.Sprint(v))
+	}
+	return &mcp.CallToolResult{Content: []mcp.Content{&mcp.TextContent{Text: string(data)}}}
+}

package/internal/service/service.go

@@ -0,0 +1,217 @@
+package service
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/m16khb/llm-wiki/internal/store"
+	"github.com/m16khb/llm-wiki/internal/wiki"
+)
+
+// Config wires the daemon/service layer.
+type Config struct {
+	VaultRoot string
+	DBPath    string
+}
+
+// Service is the shared daemon backend. All writes go through a single worker
+// queue while reads share a small in-memory metadata cache.
+type Service struct {
+	vault *wiki.Vault
+	store *store.Store
+
+	mu   sync.RWMutex
+	jobs chan captureJob
+	done chan struct{}
+
+	cacheMu sync.Mutex
+	cache   infoCache
+}
+
+type infoCache struct {
+	info      wiki.Info
+	loadedAt  time.Time
+	valid     bool
+	expiresIn time.Duration
+}
+
+type captureJob struct {
+	id    int64
+	input wiki.CaptureInput
+	done  chan captureResult
+}
+
+type captureResult struct {
+	result wiki.CaptureResult
+	err    error
+}
+
+// New creates a service with a SQLite WAL queue and a single write worker.
+func New(cfg Config) (*Service, error) {
+	vault, err := wiki.New(cfg.VaultRoot)
+	if err != nil {
+		return nil, err
+	}
+	st, err := store.Open(cfg.DBPath)
+	if err != nil {
+		return nil, err
+	}
+	s := &Service{
+		vault: vault,
+		store: st,
+		jobs:  make(chan captureJob, 128),
+		done:  make(chan struct{}),
+	}
+	s.cache.expiresIn = 2 * time.Second
+	go s.captureWorker()
+	return s, nil
+}
+
+func (s *Service) Close() error {
+	if s == nil {
+		return nil
+	}
+	select {
+	case <-s.done:
+	default:
+		close(s.done)
+	}
+	if s.store != nil {
+		return s.store.Close()
+	}
+	return nil
+}
+
+func (s *Service) VaultRoot() string {
+	return s.vault.Root
+}
+
+func (s *Service) DBPath() string {
+	return s.store.Path
+}
+
+func (s *Service) Info() (wiki.Info, error) {
+	s.cacheMu.Lock()
+	if s.cache.valid && time.Since(s.cache.loadedAt) < s.cache.expiresIn {
+		info := s.cache.info
+		s.cacheMu.Unlock()
+		return info, nil
+	}
+	s.cacheMu.Unlock()
+
+	s.mu.RLock()
+	info, err := s.vault.Info()
+	s.mu.RUnlock()
+	if err != nil {
+		return wiki.Info{}, err
+	}
+
+	s.cacheMu.Lock()
+	s.cache.info = info
+	s.cache.loadedAt = time.Now()
+	s.cache.valid = true
+	s.cacheMu.Unlock()
+	return info, nil
+}
+
+func (s *Service) Search(opts wiki.SearchOptions) ([]wiki.SearchResult, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.vault.Search(opts)
+}
+
+func (s *Service) ReadPage(ref string, maxBytes int) (wiki.Page, string, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.vault.ReadPage(ref, maxBytes)
+}
+
+func (s *Service) Lint() (wiki.LintResult, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.vault.Lint()
+}
+
+func (s *Service) Capture(in wiki.CaptureInput) (wiki.CaptureResult, error) {
+	return s.CaptureContext(context.Background(), in)
+}
+
+// CaptureContext durably enqueues a capture job and waits for the daemon's
+// single writer to complete it.
+func (s *Service) CaptureContext(ctx context.Context, in wiki.CaptureInput) (wiki.CaptureResult, error) {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	id, err := s.store.Enqueue(ctx, "wiki_capture", in)
+	if err != nil {
+		return wiki.CaptureResult{}, err
+	}
+	job := captureJob{id: id, input: in, done: make(chan captureResult, 1)}
+	select {
+	case s.jobs <- job:
+	case <-ctx.Done():
+		_ = s.store.MarkFailed(context.Background(), id, ctx.Err())
+		return wiki.CaptureResult{}, ctx.Err()
+	case <-s.done:
+		err := errors.New("service is closed")
+		_ = s.store.MarkFailed(context.Background(), id, err)
+		return wiki.CaptureResult{}, err
+	}
+	select {
+	case res := <-job.done:
+		return res.result, res.err
+	case <-ctx.Done():
+		return wiki.CaptureResult{}, ctx.Err()
+	case <-s.done:
+		return wiki.CaptureResult{}, errors.New("service is closed")
+	}
+}
+
+func (s *Service) RecentJobs(ctx context.Context, limit int) ([]store.Job, error) {
+	return s.store.RecentJobs(ctx, limit)
+}
+
+func (s *Service) captureWorker() {
+	for {
+		select {
+		case <-s.done:
+			return
+		case job := <-s.jobs:
+			s.runCaptureJob(job)
+		}
+	}
+}
+
+func (s *Service) runCaptureJob(job captureJob) {
+	ctx := context.Background()
+	if err := s.store.MarkRunning(ctx, job.id); err != nil {
+		job.done <- captureResult{err: err}
+		return
+	}
+	s.mu.Lock()
+	result, err := s.vault.Capture(job.input)
+	s.mu.Unlock()
+	if err != nil {
+		markErr := s.store.MarkFailed(ctx, job.id, err)
+		if markErr != nil {
+			err = fmt.Errorf("%w; additionally failed to mark job failed: %v", err, markErr)
+		}
+		job.done <- captureResult{err: err}
+		return
+	}
+	s.invalidateInfoCache()
+	if err := s.store.MarkCompleted(ctx, job.id, result); err != nil {
+		job.done <- captureResult{result: result, err: err}
+		return
+	}
+	job.done <- captureResult{result: result}
+}
+
+func (s *Service) invalidateInfoCache() {
+	s.cacheMu.Lock()
+	s.cache.valid = false
+	s.cacheMu.Unlock()
+}

package/internal/service/service_test.go

@@ -0,0 +1,75 @@
+package service
+
+import (
+	"context"
+	"path/filepath"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/m16khb/llm-wiki/internal/store"
+	"github.com/m16khb/llm-wiki/internal/wiki"
+)
+
+func TestServiceCaptureSerializesThroughSQLiteQueue(t *testing.T) {
+	tmp := t.TempDir()
+	s, err := New(Config{VaultRoot: tmp, DBPath: filepath.Join(tmp, "queue.db")})
+	if err != nil {
+		t.Fatalf("New() error = %v", err)
+	}
+	defer s.Close()
+	s.vault.Now = func() time.Time { return time.Date(2026, 5, 23, 12, 0, 0, 0, time.UTC) }
+
+	const n = 8
+	var wg sync.WaitGroup
+	errs := make(chan error, n)
+	for i := 0; i < n; i++ {
+		i := i
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			_, err := s.Capture(wiki.CaptureInput{Title: "Note", Body: "body", Slug: "note-" + string(rune('a'+i))})
+			errs <- err
+		}()
+	}
+	wg.Wait()
+	close(errs)
+	for err := range errs {
+		if err != nil {
+			t.Fatalf("Capture() error = %v", err)
+		}
+	}
+
+	jobs, err := s.RecentJobs(context.Background(), 20)
+	if err != nil {
+		t.Fatalf("RecentJobs() error = %v", err)
+	}
+	if len(jobs) != n {
+		t.Fatalf("got %d jobs, want %d: %+v", len(jobs), n, jobs)
+	}
+	for _, job := range jobs {
+		if job.Status != store.StatusCompleted {
+			t.Fatalf("job not completed: %+v", job)
+		}
+	}
+}
+
+func TestServiceCaptureAuditsFailedJob(t *testing.T) {
+	tmp := t.TempDir()
+	s, err := New(Config{VaultRoot: tmp, DBPath: filepath.Join(tmp, "queue.db")})
+	if err != nil {
+		t.Fatalf("New() error = %v", err)
+	}
+	defer s.Close()
+
+	if _, err := s.Capture(wiki.CaptureInput{Title: "Bad", Body: "body", Folder: "10-sources", Slug: "bad"}); err == nil {
+		t.Fatalf("expected protected folder capture to fail")
+	}
+	jobs, err := s.RecentJobs(context.Background(), 1)
+	if err != nil {
+		t.Fatalf("RecentJobs() error = %v", err)
+	}
+	if len(jobs) != 1 || jobs[0].Status != store.StatusFailed || jobs[0].Error == "" {
+		t.Fatalf("expected failed audited job, got %+v", jobs)
+	}
+}