@m16khb/llm-wiki 0.1.0

package/internal/store/store.go

@@ -0,0 +1,245 @@
+package store
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+
+	_ "modernc.org/sqlite"
+)
+
+// Store persists daemon queue/audit state in SQLite WAL mode.
+type Store struct {
+	Path string
+	db   *sql.DB
+	now  func() time.Time
+}
+
+// Job records one queued daemon operation.
+type Job struct {
+	ID          int64  `json:"id"`
+	Kind        string `json:"kind"`
+	Status      string `json:"status"`
+	PayloadJSON string `json:"payload_json"`
+	ResultJSON  string `json:"result_json,omitempty"`
+	Error       string `json:"error,omitempty"`
+	CreatedAt   string `json:"created_at"`
+	UpdatedAt   string `json:"updated_at"`
+	StartedAt   string `json:"started_at,omitempty"`
+	FinishedAt  string `json:"finished_at,omitempty"`
+}
+
+const (
+	StatusQueued    = "queued"
+	StatusRunning   = "running"
+	StatusCompleted = "completed"
+	StatusFailed    = "failed"
+)
+
+// DefaultPath returns the default durable SQLite queue path.
+func DefaultPath() string {
+	if v := os.Getenv("LLM_WIKI_DB"); v != "" {
+		return expandHome(v)
+	}
+	dir, err := os.UserConfigDir()
+	if err != nil || dir == "" {
+		if home, homeErr := os.UserHomeDir(); homeErr == nil && home != "" {
+			dir = filepath.Join(home, ".config")
+		} else {
+			dir = "."
+		}
+	}
+	return filepath.Join(dir, "llm-wiki", "llm-wiki.db")
+}
+
+// Open opens and migrates a SQLite-backed queue store.
+func Open(path string) (*Store, error) {
+	if path == "" {
+		path = DefaultPath()
+	}
+	path = expandHome(path)
+	abs, err := filepath.Abs(path)
+	if err != nil {
+		return nil, err
+	}
+	if err := os.MkdirAll(filepath.Dir(abs), 0o755); err != nil {
+		return nil, err
+	}
+	db, err := sql.Open("sqlite", abs)
+	if err != nil {
+		return nil, err
+	}
+	db.SetMaxOpenConns(1)
+	s := &Store{Path: abs, db: db, now: time.Now}
+	if err := s.configure(context.Background()); err != nil {
+		db.Close()
+		return nil, err
+	}
+	if err := s.migrate(context.Background()); err != nil {
+		db.Close()
+		return nil, err
+	}
+	return s, nil
+}
+
+func (s *Store) Close() error {
+	if s == nil || s.db == nil {
+		return nil
+	}
+	return s.db.Close()
+}
+
+func (s *Store) configure(ctx context.Context) error {
+	pragmas := []string{
+		"PRAGMA journal_mode = WAL",
+		"PRAGMA synchronous = NORMAL",
+		"PRAGMA busy_timeout = 5000",
+		"PRAGMA foreign_keys = ON",
+	}
+	for _, stmt := range pragmas {
+		if _, err := s.db.ExecContext(ctx, stmt); err != nil {
+			return fmt.Errorf("configure sqlite %q: %w", stmt, err)
+		}
+	}
+	return nil
+}
+
+func (s *Store) migrate(ctx context.Context) error {
+	stmts := []string{
+		`CREATE TABLE IF NOT EXISTS jobs (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			kind TEXT NOT NULL,
+			status TEXT NOT NULL,
+			payload_json TEXT NOT NULL,
+			result_json TEXT,
+			error TEXT,
+			created_at TEXT NOT NULL,
+			updated_at TEXT NOT NULL,
+			started_at TEXT,
+			finished_at TEXT
+		)`,
+		`CREATE INDEX IF NOT EXISTS idx_jobs_status_id ON jobs(status, id)`,
+		`CREATE INDEX IF NOT EXISTS idx_jobs_kind_id ON jobs(kind, id)`,
+	}
+	for _, stmt := range stmts {
+		if _, err := s.db.ExecContext(ctx, stmt); err != nil {
+			return fmt.Errorf("migrate sqlite: %w", err)
+		}
+	}
+	return nil
+}
+
+// Enqueue stores a job payload durably before the daemon worker executes it.
+func (s *Store) Enqueue(ctx context.Context, kind string, payload any) (int64, error) {
+	if kind == "" {
+		return 0, errors.New("job kind is required")
+	}
+	data, err := json.Marshal(payload)
+	if err != nil {
+		return 0, fmt.Errorf("marshal job payload: %w", err)
+	}
+	now := s.timestamp()
+	res, err := s.db.ExecContext(ctx, `INSERT INTO jobs(kind, status, payload_json, created_at, updated_at) VALUES(?, ?, ?, ?, ?)`, kind, StatusQueued, string(data), now, now)
+	if err != nil {
+		return 0, fmt.Errorf("enqueue job: %w", err)
+	}
+	id, err := res.LastInsertId()
+	if err != nil {
+		return 0, fmt.Errorf("enqueue job id: %w", err)
+	}
+	return id, nil
+}
+
+func (s *Store) MarkRunning(ctx context.Context, id int64) error {
+	now := s.timestamp()
+	return s.update(ctx, id, `UPDATE jobs SET status = ?, started_at = ?, updated_at = ? WHERE id = ?`, StatusRunning, now, now, id)
+}
+
+func (s *Store) MarkCompleted(ctx context.Context, id int64, result any) error {
+	data, err := json.Marshal(result)
+	if err != nil {
+		return fmt.Errorf("marshal job result: %w", err)
+	}
+	now := s.timestamp()
+	return s.update(ctx, id, `UPDATE jobs SET status = ?, result_json = ?, error = NULL, finished_at = ?, updated_at = ? WHERE id = ?`, StatusCompleted, string(data), now, now, id)
+}
+
+func (s *Store) MarkFailed(ctx context.Context, id int64, jobErr error) error {
+	msg := ""
+	if jobErr != nil {
+		msg = jobErr.Error()
+	}
+	now := s.timestamp()
+	return s.update(ctx, id, `UPDATE jobs SET status = ?, error = ?, finished_at = ?, updated_at = ? WHERE id = ?`, StatusFailed, msg, now, now, id)
+}
+
+func (s *Store) update(ctx context.Context, id int64, stmt string, args ...any) error {
+	res, err := s.db.ExecContext(ctx, stmt, args...)
+	if err != nil {
+		return fmt.Errorf("update job %d: %w", id, err)
+	}
+	n, err := res.RowsAffected()
+	if err != nil {
+		return fmt.Errorf("update job %d rows: %w", id, err)
+	}
+	if n == 0 {
+		return fmt.Errorf("job not found: %d", id)
+	}
+	return nil
+}
+
+func (s *Store) Job(ctx context.Context, id int64) (Job, error) {
+	row := s.db.QueryRowContext(ctx, `SELECT id, kind, status, payload_json, COALESCE(result_json, ''), COALESCE(error, ''), created_at, updated_at, COALESCE(started_at, ''), COALESCE(finished_at, '') FROM jobs WHERE id = ?`, id)
+	return scanJob(row)
+}
+
+func (s *Store) RecentJobs(ctx context.Context, limit int) ([]Job, error) {
+	if limit <= 0 || limit > 100 {
+		limit = 20
+	}
+	rows, err := s.db.QueryContext(ctx, `SELECT id, kind, status, payload_json, COALESCE(result_json, ''), COALESCE(error, ''), created_at, updated_at, COALESCE(started_at, ''), COALESCE(finished_at, '') FROM jobs ORDER BY id DESC LIMIT ?`, limit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var jobs []Job
+	for rows.Next() {
+		job, err := scanJob(rows)
+		if err != nil {
+			return nil, err
+		}
+		jobs = append(jobs, job)
+	}
+	return jobs, rows.Err()
+}
+
+func scanJob(scanner interface{ Scan(dest ...any) error }) (Job, error) {
+	var j Job
+	if err := scanner.Scan(&j.ID, &j.Kind, &j.Status, &j.PayloadJSON, &j.ResultJSON, &j.Error, &j.CreatedAt, &j.UpdatedAt, &j.StartedAt, &j.FinishedAt); err != nil {
+		return Job{}, err
+	}
+	return j, nil
+}
+
+func (s *Store) timestamp() string {
+	return s.now().UTC().Format(time.RFC3339Nano)
+}
+
+func expandHome(path string) string {
+	if path == "~" {
+		if home, err := os.UserHomeDir(); err == nil {
+			return home
+		}
+	}
+	if len(path) >= 2 && path[:2] == "~/" {
+		if home, err := os.UserHomeDir(); err == nil {
+			return filepath.Join(home, path[2:])
+		}
+	}
+	return path
+}

package/internal/store/store_test.go

@@ -0,0 +1,48 @@
+package store
+
+import (
+	"context"
+	"path/filepath"
+	"testing"
+)
+
+func TestStorePersistsQueueJobs(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "queue.db")
+	s, err := Open(path)
+	if err != nil {
+		t.Fatalf("Open() error = %v", err)
+	}
+	defer s.Close()
+
+	ctx := context.Background()
+	id, err := s.Enqueue(ctx, "wiki_capture", map[string]string{"title": "A"})
+	if err != nil {
+		t.Fatalf("Enqueue() error = %v", err)
+	}
+	if err := s.MarkRunning(ctx, id); err != nil {
+		t.Fatalf("MarkRunning() error = %v", err)
+	}
+	if err := s.MarkCompleted(ctx, id, map[string]string{"path": "20-wiki/concepts/a.md"}); err != nil {
+		t.Fatalf("MarkCompleted() error = %v", err)
+	}
+	job, err := s.Job(ctx, id)
+	if err != nil {
+		t.Fatalf("Job() error = %v", err)
+	}
+	if job.Status != StatusCompleted || job.ResultJSON == "" || job.StartedAt == "" || job.FinishedAt == "" {
+		t.Fatalf("unexpected job: %+v", job)
+	}
+
+	reopened, err := Open(path)
+	if err != nil {
+		t.Fatalf("reopen error = %v", err)
+	}
+	defer reopened.Close()
+	jobs, err := reopened.RecentJobs(ctx, 10)
+	if err != nil {
+		t.Fatalf("RecentJobs() error = %v", err)
+	}
+	if len(jobs) != 1 || jobs[0].ID != id || jobs[0].Status != StatusCompleted {
+		t.Fatalf("unexpected jobs after reopen: %+v", jobs)
+	}
+}

package/internal/wiki/capture.go

@@ -0,0 +1,177 @@
+package wiki
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"time"
+)
+
+// CaptureInput describes an additive wiki write.
+type CaptureInput struct {
+	Title     string   `json:"title" jsonschema:"human title for the page"`
+	Body      string   `json:"body" jsonschema:"markdown body without frontmatter"`
+	Type      string   `json:"type,omitempty" jsonschema:"concept, entity, summary, session, reference, or lint-report"`
+	Status    string   `json:"status,omitempty" jsonschema:"draft, active, or archived"`
+	Domain    string   `json:"domain,omitempty" jsonschema:"frontmatter domain value"`
+	Tags      []string `json:"tags,omitempty" jsonschema:"frontmatter tags"`
+	Folder    string   `json:"folder,omitempty" jsonschema:"optional target folder under 20-wiki, 30-sessions, or 00-meta/reports"`
+	Slug      string   `json:"slug,omitempty" jsonschema:"optional kebab-case filename without .md"`
+	Overwrite bool     `json:"overwrite,omitempty" jsonschema:"if true, replace an existing file in allowed folders"`
+}
+
+// CaptureResult describes a written page.
+type CaptureResult struct {
+	Path      string `json:"path"`
+	Slug      string `json:"slug"`
+	Created   bool   `json:"created"`
+	Overwrote bool   `json:"overwrote"`
+}
+
+func (v *Vault) Capture(in CaptureInput) (CaptureResult, error) {
+	in.Title = strings.TrimSpace(in.Title)
+	if in.Title == "" {
+		return CaptureResult{}, errors.New("title is required")
+	}
+	if strings.TrimSpace(in.Body) == "" {
+		return CaptureResult{}, errors.New("body is required")
+	}
+	if in.Type == "" {
+		in.Type = "concept"
+	}
+	if in.Status == "" {
+		in.Status = "draft"
+	}
+	if in.Domain == "" {
+		in.Domain = "dev-fundamentals"
+	}
+	slug := in.Slug
+	if slug == "" {
+		slug = Slugify(in.Title)
+	}
+	if slug == "" {
+		slug = "note-" + strings.ReplaceAll(v.nowTime().Format("20060102-150405"), ":", "-")
+	}
+	folder := v.chooseFolder(in)
+	if !isAllowedWriteFolder(folder) {
+		return CaptureResult{}, fmt.Errorf("folder is not allowed for writes: %s", folder)
+	}
+	rel := filepath.ToSlash(filepath.Join(folder, slug+".md"))
+	abs, err := v.SafeJoin(rel)
+	if err != nil {
+		return CaptureResult{}, err
+	}
+	if _, err := os.Stat(abs); err == nil && !in.Overwrite {
+		return CaptureResult{}, fmt.Errorf("page already exists: %s", rel)
+	}
+	if err := os.MkdirAll(filepath.Dir(abs), 0o755); err != nil {
+		return CaptureResult{}, err
+	}
+	now := v.nowDate()
+	content := renderCapture(now, slug, in)
+	_, statErr := os.Stat(abs)
+	if err := os.WriteFile(abs, []byte(content), 0o644); err != nil {
+		return CaptureResult{}, err
+	}
+	return CaptureResult{Path: rel, Slug: slug, Created: os.IsNotExist(statErr), Overwrote: statErr == nil}, nil
+}
+
+func (v *Vault) chooseFolder(in CaptureInput) string {
+	if strings.TrimSpace(in.Folder) != "" {
+		return strings.Trim(strings.TrimSpace(filepath.ToSlash(in.Folder)), "/")
+	}
+	year := v.nowDate()[:4]
+	switch in.Type {
+	case "session":
+		return "30-sessions/" + year
+	case "summary":
+		return "20-wiki/summaries/" + year
+	case "entity":
+		return "20-wiki/entities"
+	case "lint-report", "report":
+		return "00-meta/reports"
+	default:
+		return "20-wiki/concepts"
+	}
+}
+
+func isAllowedWriteFolder(folder string) bool {
+	folder = strings.Trim(strings.TrimSpace(filepath.ToSlash(folder)), "/")
+	allowedPrefixes := []string{
+		"20-wiki/concepts",
+		"20-wiki/entities",
+		"20-wiki/summaries",
+		"30-sessions",
+		"00-meta/reports",
+	}
+	for _, prefix := range allowedPrefixes {
+		if folder == prefix || strings.HasPrefix(folder, prefix+"/") {
+			return true
+		}
+	}
+	return false
+}
+
+func renderCapture(date, slug string, in CaptureInput) string {
+	var b strings.Builder
+	b.WriteString("---\n")
+	fmt.Fprintf(&b, "title: %s\n", yamlQuote(in.Title))
+	fmt.Fprintf(&b, "type: %s\n", in.Type)
+	fmt.Fprintf(&b, "status: %s\n", in.Status)
+	fmt.Fprintf(&b, "created: %s\n", date)
+	fmt.Fprintf(&b, "updated: %s\n", date)
+	fmt.Fprintf(&b, "tags: [%s]\n", joinYAMLList(in.Tags))
+	fmt.Fprintf(&b, "domain: %s\n", in.Domain)
+	b.WriteString("---\n\n")
+	if !strings.HasPrefix(strings.TrimSpace(in.Body), "#") {
+		fmt.Fprintf(&b, "# %s\n\n", in.Title)
+	}
+	b.WriteString(strings.TrimSpace(in.Body))
+	b.WriteString("\n\n## Changelog\n\n")
+	fmt.Fprintf(&b, "- %s: Created via llm-wiki MCP capture (`%s`).\n", date, slug)
+	return b.String()
+}
+
+func (v *Vault) nowTime() time.Time {
+	if v.Now != nil {
+		return v.Now()
+	}
+	return time.Now()
+}
+
+func (v *Vault) nowDate() string {
+	return v.nowTime().Format("2006-01-02")
+}
+
+var slugInvalid = regexp.MustCompile(`[^a-z0-9]+`)
+
+func Slugify(s string) string {
+	s = strings.ToLower(strings.TrimSpace(s))
+	s = slugInvalid.ReplaceAllString(s, "-")
+	s = strings.Trim(s, "-")
+	return s
+}
+
+func yamlQuote(s string) string {
+	s = strings.ReplaceAll(s, "\\", "\\\\")
+	s = strings.ReplaceAll(s, "\"", "\\\"")
+	return "\"" + s + "\""
+}
+
+func joinYAMLList(values []string) string {
+	if len(values) == 0 {
+		return ""
+	}
+	parts := make([]string, 0, len(values))
+	for _, v := range values {
+		v = strings.TrimSpace(v)
+		if v == "" {
+			continue
+		}
+		parts = append(parts, v)
+	}
+	return strings.Join(parts, ", ")
+}

package/internal/wiki/frontmatter.go

@@ -0,0 +1,158 @@
+package wiki
+
+import (
+	"bufio"
+	"strings"
+)
+
+// Metadata is the subset of Obsidian/YAML frontmatter the adapter needs.
+type Metadata struct {
+	Title   string   `json:"title,omitempty"`
+	Type    string   `json:"type,omitempty"`
+	Status  string   `json:"status,omitempty"`
+	Created string   `json:"created,omitempty"`
+	Updated string   `json:"updated,omitempty"`
+	Domain  string   `json:"domain,omitempty"`
+	Tags    []string `json:"tags,omitempty"`
+	Sources []string `json:"sources,omitempty"`
+	Related []string `json:"related,omitempty"`
+}
+
+// ParseFrontmatter extracts a conservative subset of YAML frontmatter. It is
+// intentionally dependency-free: the LLM Wiki schema uses simple scalar fields
+// and string/list fields that this parser handles.
+func ParseFrontmatter(content string) (Metadata, string, bool) {
+	var meta Metadata
+	if !strings.HasPrefix(content, "---\n") && content != "---" {
+		return meta, content, false
+	}
+	lines := strings.Split(content, "\n")
+	if len(lines) == 0 || strings.TrimSpace(lines[0]) != "---" {
+		return meta, content, false
+	}
+	end := -1
+	for i := 1; i < len(lines); i++ {
+		if strings.TrimSpace(lines[i]) == "---" {
+			end = i
+			break
+		}
+	}
+	if end < 0 {
+		return meta, content, false
+	}
+	body := strings.Join(lines[end+1:], "\n")
+	parseMetaBlock(strings.Join(lines[1:end], "\n"), &meta)
+	return meta, body, true
+}
+
+func parseMetaBlock(block string, meta *Metadata) {
+	s := bufio.NewScanner(strings.NewReader(block))
+	var currentList string
+	for s.Scan() {
+		line := strings.TrimRight(s.Text(), "\r")
+		trimmed := strings.TrimSpace(line)
+		if trimmed == "" || strings.HasPrefix(trimmed, "#") {
+			continue
+		}
+		if strings.HasPrefix(trimmed, "- ") && currentList != "" {
+			appendList(meta, currentList, cleanScalar(strings.TrimSpace(strings.TrimPrefix(trimmed, "- "))))
+			continue
+		}
+		currentList = ""
+		parts := strings.SplitN(trimmed, ":", 2)
+		if len(parts) != 2 {
+			continue
+		}
+		key := strings.TrimSpace(parts[0])
+		value := strings.TrimSpace(parts[1])
+		if value == "" {
+			currentList = key
+			continue
+		}
+		switch key {
+		case "title":
+			meta.Title = cleanScalar(value)
+		case "type":
+			meta.Type = cleanScalar(value)
+		case "status":
+			meta.Status = cleanScalar(value)
+		case "created":
+			meta.Created = cleanScalar(value)
+		case "updated":
+			meta.Updated = cleanScalar(value)
+		case "domain":
+			meta.Domain = cleanScalar(value)
+		case "tags":
+			meta.Tags = parseInlineList(value)
+		case "sources":
+			meta.Sources = parseInlineList(value)
+		case "related":
+			meta.Related = parseInlineList(value)
+		}
+	}
+}
+
+func appendList(meta *Metadata, key string, value string) {
+	switch key {
+	case "tags":
+		meta.Tags = append(meta.Tags, value)
+	case "sources":
+		meta.Sources = append(meta.Sources, value)
+	case "related":
+		meta.Related = append(meta.Related, value)
+	}
+}
+
+func parseInlineList(value string) []string {
+	value = strings.TrimSpace(value)
+	if value == "" || value == "[]" {
+		return nil
+	}
+	if strings.HasPrefix(value, "[") && strings.HasSuffix(value, "]") {
+		value = strings.TrimSpace(strings.TrimSuffix(strings.TrimPrefix(value, "["), "]"))
+		if value == "" {
+			return nil
+		}
+		parts := splitCSV(value)
+		out := make([]string, 0, len(parts))
+		for _, p := range parts {
+			if cleaned := cleanScalar(p); cleaned != "" {
+				out = append(out, cleaned)
+			}
+		}
+		return out
+	}
+	return []string{cleanScalar(value)}
+}
+
+func splitCSV(s string) []string {
+	var parts []string
+	var b strings.Builder
+	quote := rune(0)
+	for _, r := range s {
+		switch {
+		case quote != 0:
+			if r == quote {
+				quote = 0
+			}
+			b.WriteRune(r)
+		case r == '\'' || r == '"':
+			quote = r
+			b.WriteRune(r)
+		case r == ',':
+			parts = append(parts, b.String())
+			b.Reset()
+		default:
+			b.WriteRune(r)
+		}
+	}
+	parts = append(parts, b.String())
+	return parts
+}
+
+func cleanScalar(value string) string {
+	value = strings.TrimSpace(value)
+	value = strings.Trim(value, "\"")
+	value = strings.Trim(value, "'")
+	return value
+}