@m16khb/llm-wiki 0.1.0 → 0.1.1

package/internal/sessionctx/sessionctx.go

@@ -0,0 +1,649 @@
+package sessionctx
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+
+	"github.com/m16khb/llm-wiki/internal/wiki"
+)
+
+// Options controls project-aware wiki context lookup for lifecycle hooks.
+type Options struct {
+	ProjectPath string
+	Query       string
+	Limit       int
+}
+
+// Project describes the current coding workspace using small deterministic cues.
+type Project struct {
+	Path      string   `json:"path"`
+	Name      string   `json:"name"`
+	Terms     []string `json:"terms"`
+	TechTerms []string `json:"tech_terms,omitempty"`
+	Sources   []string `json:"sources,omitempty"`
+}
+
+// Context is the hook-friendly wiki context bundle.
+type Context struct {
+	Project     Project             `json:"project"`
+	Query       string              `json:"query"`
+	Results     []wiki.SearchResult `json:"results"`
+	TechResults []wiki.SearchResult `json:"tech_results,omitempty"`
+}
+
+// CaptureBlock is a selected note block emitted by an agent for durable capture.
+type CaptureBlock struct {
+	Title string   `json:"title"`
+	Tags  []string `json:"tags,omitempty"`
+	Body  string   `json:"body"`
+}
+
+var tokenSplit = regexp.MustCompile(`[^A-Za-z0-9가-힣]+`)
+
+// BuildContext derives project terms, combines them with an optional prompt
+// query, and searches the configured LLM Wiki vault.
+func BuildContext(v *wiki.Vault, opts Options) (Context, error) {
+	project, err := InspectProject(opts.ProjectPath)
+	if err != nil {
+		return Context{}, err
+	}
+	query := strings.TrimSpace(opts.Query)
+	if len(project.Terms) > 0 {
+		if query == "" {
+			query = strings.Join(project.Terms, " ")
+		} else {
+			query = query + " " + strings.Join(project.Terms, " ")
+		}
+	}
+	limit := opts.Limit
+	if limit <= 0 {
+		limit = 5
+	}
+	if limit > 20 {
+		limit = 20
+	}
+	results, err := v.Search(wiki.SearchOptions{Query: query, Limit: limit})
+	if err != nil {
+		return Context{}, err
+	}
+	var techResults []wiki.SearchResult
+	if len(project.TechTerms) > 0 {
+		techResults, err = buildTechResults(v, project, limit)
+		if err != nil {
+			return Context{}, err
+		}
+	}
+	return Context{Project: project, Query: query, Results: results, TechResults: techResults}, nil
+}
+
+// InspectProject collects stable, low-cost project identity terms without
+// scanning source files broadly.
+func InspectProject(projectPath string) (Project, error) {
+	if strings.TrimSpace(projectPath) == "" {
+		wd, err := os.Getwd()
+		if err != nil {
+			return Project{}, err
+		}
+		projectPath = wd
+	}
+	abs, err := filepath.Abs(projectPath)
+	if err != nil {
+		return Project{}, err
+	}
+	terms := newTermSet()
+	techTerms := newTermSet()
+	name := filepath.Base(abs)
+	terms.addTerm(strings.ToLower(name))
+	terms.addText(name)
+	sources := []string{"directory"}
+
+	if module, goMod := readGoModule(abs); module != "" {
+		sources = append(sources, "go.mod")
+		techTerms.addTerms("go", "golang")
+		terms.addText(module)
+		if base := pathBase(module); base != "" {
+			name = base
+			terms.addTerm(strings.ToLower(base))
+			terms.addText(base)
+		}
+		if hasAnyFold(goMod, "swaggo", "swagger", "openapi") {
+			techTerms.addTerms("swagger", "openapi", "swaggo")
+		}
+		if hasAnyFold(goMod, "modelcontextprotocol", "mcp") {
+			techTerms.addTerm("mcp")
+		}
+		if hasAnyFold(goMod, "sqlite") {
+			techTerms.addTerm("sqlite")
+		}
+		if hasAnyFold(goMod, "gin-gonic/gin") {
+			techTerms.addTerm("gin")
+		}
+		if hasAnyFold(goMod, "gorm.io/gorm") {
+			techTerms.addTerm("gorm")
+		}
+		if hasAnyFold(goMod, "redis") {
+			techTerms.addTerm("redis")
+		}
+	}
+	pkgName, packageJSON, packageHasBin := readPackage(abs)
+	if pkgName != "" {
+		sources = append(sources, "package.json")
+		techTerms.addTerms("node", "npm")
+		if packageHasBin {
+			techTerms.addTerm("npx")
+		}
+		terms.addTerm(strings.ToLower(pkgName))
+		terms.addText(pkgName)
+		if name == filepath.Base(abs) {
+			name = pkgName
+		}
+	}
+	if hasAnyFold(packageJSON, "swagger", "openapi", "swaggo") {
+		techTerms.addTerms("swagger", "openapi")
+	}
+	if hasKnownAPISpecFile(abs) {
+		techTerms.addTerms("swagger", "openapi")
+	}
+	if hasExistingFile(abs, ".mcp.json") || hasExistingFile(abs, ".codex/hooks.json") || hasExistingFile(abs, ".claude/settings.json") {
+		techTerms.addTerm("mcp")
+	}
+	heading, readme := readReadme(abs)
+	if heading != "" {
+		sources = append(sources, "README.md")
+		terms.addText(heading)
+	}
+	if hasAnyFold(readme, "model context protocol", "mcp") {
+		techTerms.addTerm("mcp")
+	}
+	if hasAnyFold(readme, "sqlite") {
+		techTerms.addTerm("sqlite")
+	}
+	if hasAnyFold(readme, "obsidian") {
+		techTerms.addTerm("obsidian")
+	}
+	return Project{Path: abs, Name: name, Terms: terms.values(), TechTerms: techTerms.values(), Sources: sources}, nil
+}
+
+func readGoModule(root string) (string, string) {
+	content := readTextFile(filepath.Join(root, "go.mod"))
+	for _, line := range strings.Split(content, "\n") {
+		line = strings.TrimSpace(line)
+		if strings.HasPrefix(line, "module ") {
+			return strings.TrimSpace(strings.TrimPrefix(line, "module ")), content
+		}
+	}
+	return "", content
+}
+
+func readPackage(root string) (string, string, bool) {
+	content := readTextFile(filepath.Join(root, "package.json"))
+	var pkg struct {
+		Name string          `json:"name"`
+		Bin  json.RawMessage `json:"bin"`
+	}
+	if err := json.Unmarshal([]byte(content), &pkg); err != nil {
+		return "", content, false
+	}
+	return strings.TrimSpace(pkg.Name), content, len(pkg.Bin) > 0 && string(pkg.Bin) != "null"
+}
+
+func readReadme(root string) (string, string) {
+	for _, name := range []string{"README.md", "readme.md"} {
+		data, err := os.ReadFile(filepath.Join(root, name))
+		if err != nil {
+			continue
+		}
+		content := string(data)
+		for _, line := range strings.Split(string(data), "\n") {
+			line = strings.TrimSpace(line)
+			if strings.HasPrefix(line, "# ") {
+				return strings.TrimSpace(strings.TrimPrefix(line, "# ")), content
+			}
+		}
+		return "", content
+	}
+	return "", ""
+}
+
+func readTextFile(path string) string {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return ""
+	}
+	return string(data)
+}
+
+func hasAnyFold(text string, needles ...string) bool {
+	text = strings.ToLower(text)
+	for _, needle := range needles {
+		if strings.Contains(text, strings.ToLower(needle)) {
+			return true
+		}
+	}
+	return false
+}
+
+func hasKnownAPISpecFile(root string) bool {
+	for _, rel := range []string{
+		"swagger.yaml",
+		"swagger.yml",
+		"swagger.json",
+		"openapi.yaml",
+		"openapi.yml",
+		"openapi.json",
+		"docs/swagger.yaml",
+		"docs/swagger.yml",
+		"docs/swagger.json",
+		"docs/openapi.yaml",
+		"docs/openapi.yml",
+		"docs/openapi.json",
+		"api/swagger.yaml",
+		"api/swagger.yml",
+		"api/swagger.json",
+		"api/openapi.yaml",
+		"api/openapi.yml",
+		"api/openapi.json",
+		"scripts/generate-swagger.sh",
+	} {
+		if _, err := os.Stat(filepath.Join(root, filepath.FromSlash(rel))); err == nil {
+			return true
+		}
+	}
+	return false
+}
+
+func hasExistingFile(root, rel string) bool {
+	_, err := os.Stat(filepath.Join(root, filepath.FromSlash(rel)))
+	return err == nil
+}
+
+func buildTechResults(v *wiki.Vault, project Project, limit int) ([]wiki.SearchResult, error) {
+	resultLimit := techResultLimit(project, limit)
+	candidateLimit := resultLimit * 3
+	if candidateLimit < 10 {
+		candidateLimit = 10
+	}
+	if candidateLimit > 50 {
+		candidateLimit = 50
+	}
+	var merged []wiki.SearchResult
+	seen := map[string]bool{}
+	addResults := func(results []wiki.SearchResult) {
+		for _, result := range results {
+			if result.Score < 5 {
+				continue
+			}
+			if !resultMatchesProject(project, result) && !resultIdentityMatchesAnyTerm(result, project.TechTerms) {
+				continue
+			}
+			if seen[result.Slug] {
+				continue
+			}
+			seen[result.Slug] = true
+			merged = append(merged, result)
+		}
+	}
+	for _, term := range project.TechTerms {
+		results, err := v.Search(wiki.SearchOptions{Query: term, Limit: 4})
+		if err != nil {
+			return nil, err
+		}
+		addResults(results)
+	}
+	results, err := v.Search(wiki.SearchOptions{Query: strings.Join(project.TechTerms, " "), Limit: candidateLimit})
+	if err != nil {
+		return nil, err
+	}
+	addResults(results)
+	return prioritizeTechResults(project, merged, resultLimit), nil
+}
+
+func techResultLimit(project Project, limit int) int {
+	resultLimit := limit * 2
+	if resultLimit < len(project.TechTerms) {
+		resultLimit = len(project.TechTerms)
+	}
+	if resultLimit < 5 {
+		resultLimit = 5
+	}
+	if resultLimit > 12 {
+		resultLimit = 12
+	}
+	return resultLimit
+}
+
+func prioritizeTechResults(project Project, results []wiki.SearchResult, limit int) []wiki.SearchResult {
+	var projectSpecific []wiki.SearchResult
+	var preferred []wiki.SearchResult
+	var projectReports []wiki.SearchResult
+	for _, result := range results {
+		if isUnrelatedRepositoryReference(project, result) {
+			continue
+		}
+		if resultMatchesProject(project, result) {
+			if strings.HasPrefix(result.Path, "00-meta/reports/") {
+				projectReports = append(projectReports, result)
+				continue
+			}
+			projectSpecific = append(projectSpecific, result)
+			continue
+		}
+		preferred = append(preferred, result)
+	}
+	out := append(projectSpecific, preferred...)
+	out = append(out, projectReports...)
+	if len(out) > limit {
+		out = out[:limit]
+	}
+	return out
+}
+
+func isUnrelatedRepositoryReference(project Project, result wiki.SearchResult) bool {
+	if !strings.Contains(result.Path, "20-wiki/concepts/repository-references/") {
+		return false
+	}
+	hay := strings.ToLower(result.Path + " " + result.Slug + " " + result.Title)
+	for _, needle := range projectReferenceNeedles(project) {
+		if strings.Contains(hay, needle) {
+			return false
+		}
+	}
+	return true
+}
+
+func resultMatchesProject(project Project, result wiki.SearchResult) bool {
+	hay := strings.ToLower(result.Path + " " + result.Slug + " " + result.Title + " " + strings.Join(result.Tags, " "))
+	for _, needle := range projectReferenceNeedles(project) {
+		if strings.Contains(hay, needle) {
+			return true
+		}
+	}
+	return false
+}
+
+func projectReferenceNeedles(project Project) []string {
+	terms := newTermSet()
+	terms.addTerm(strings.ToLower(wiki.Slugify(project.Name)))
+	base := strings.ToLower(filepath.Base(project.Path))
+	terms.addTerm(base)
+	for _, term := range project.Terms {
+		if strings.Contains(term, "-") || len([]rune(term)) >= 6 {
+			terms.addTerm(strings.ToLower(term))
+		}
+	}
+	return terms.values()
+}
+
+func pathBase(path string) string {
+	path = strings.Trim(path, "/")
+	if path == "" {
+		return ""
+	}
+	parts := strings.Split(path, "/")
+	return parts[len(parts)-1]
+}
+
+type termSet struct {
+	seen map[string]bool
+	out  []string
+}
+
+func newTermSet() *termSet { return &termSet{seen: map[string]bool{}} }
+
+func (s *termSet) addTerm(term string) {
+	term = strings.Trim(strings.TrimSpace(term), "-/_.")
+	if len([]rune(term)) < 2 || s.seen[term] {
+		return
+	}
+	s.seen[term] = true
+	s.out = append(s.out, term)
+}
+
+func (s *termSet) addTerms(terms ...string) {
+	for _, term := range terms {
+		s.addTerm(term)
+	}
+}
+
+func (s *termSet) addText(text string) {
+	for _, part := range tokenSplit.Split(strings.ToLower(text), -1) {
+		part = strings.TrimSpace(part)
+		if len([]rune(part)) < 2 || s.seen[part] {
+			continue
+		}
+		s.seen[part] = true
+		s.out = append(s.out, part)
+	}
+}
+
+func (s *termSet) values() []string {
+	out := make([]string, len(s.out))
+	copy(out, s.out)
+	return out
+}
+
+// FormatAdditionalContext renders context that both Claude Code and Codex can
+// inject from SessionStart/UserPromptSubmit hooks.
+func FormatAdditionalContext(ctx Context) string {
+	var b strings.Builder
+	b.WriteString("## llm-wiki session context\n\n")
+	fmt.Fprintf(&b, "Project: `%s` (`%s`)\n", ctx.Project.Name, ctx.Project.Path)
+	if len(ctx.Project.Terms) > 0 {
+		fmt.Fprintf(&b, "Project terms: %s\n", strings.Join(ctx.Project.Terms, ", "))
+	}
+	if len(ctx.Project.TechTerms) > 0 {
+		fmt.Fprintf(&b, "Detected tech terms: %s\n", strings.Join(ctx.Project.TechTerms, ", "))
+	}
+	if strings.TrimSpace(ctx.Query) != "" {
+		fmt.Fprintf(&b, "Wiki query: `%s`\n", ctx.Query)
+	}
+	b.WriteString("\n")
+
+	reads := suggestedReads(ctx)
+	if len(reads) == 0 {
+		b.WriteString("No matching llm-wiki pages found. Use `wiki_search` or `llm-wiki session-context --query ...` when more context is needed.\n")
+	} else {
+		b.WriteString("Suggested reads:\n")
+		writeReadList(&b, reads)
+	}
+	b.WriteString("\nContext notes:\n")
+	b.WriteString("- Hook context is search-only; read listed pages before relying on details.\n")
+	b.WriteString("- Use `wiki_read` or `$llm-wiki-query <topic>` when details matter.\n")
+	b.WriteString("- Capture only curated, non-secret decisions with `wiki_capture` or `llm-wiki session-capture`.\n")
+	return b.String()
+}
+
+func suggestedReads(ctx Context) []wiki.SearchResult {
+	const maxSuggestedReads = 8
+	merged := make([]wiki.SearchResult, 0, len(ctx.Results)+len(ctx.TechResults))
+	seen := map[string]bool{}
+	add := func(results []wiki.SearchResult, includeNoisy bool) {
+		for _, result := range results {
+			if result.Slug == "" || seen[result.Slug] {
+				continue
+			}
+			if !includeNoisy && shouldSkipSuggestedRead(ctx, result) {
+				continue
+			}
+			seen[result.Slug] = true
+			merged = append(merged, result)
+			if len(merged) >= maxSuggestedReads {
+				return
+			}
+		}
+	}
+
+	add(ctx.Results, false)
+	if len(merged) < maxSuggestedReads {
+		add(ctx.TechResults, false)
+	}
+	if len(merged) == 0 {
+		add(ctx.Results, true)
+	}
+	sortSuggestedReads(ctx.Project, merged)
+	if len(merged) > maxSuggestedReads {
+		return merged[:maxSuggestedReads]
+	}
+	return merged
+}
+
+func shouldSkipSuggestedRead(ctx Context, result wiki.SearchResult) bool {
+	if isLowSignalHookResult(result) {
+		return true
+	}
+	if isUnrelatedRepositoryReference(ctx.Project, result) {
+		return true
+	}
+	if resultMatchesProject(ctx.Project, result) {
+		return false
+	}
+	return !resultIdentityMatchesAnyTerm(result, suggestedReadTerms(ctx))
+}
+
+func sortSuggestedReads(project Project, results []wiki.SearchResult) {
+	sort.SliceStable(results, func(i, j int) bool {
+		left := suggestedReadPriority(project, results[i])
+		right := suggestedReadPriority(project, results[j])
+		if left == right {
+			return false
+		}
+		return left < right
+	})
+}
+
+func suggestedReadPriority(project Project, result wiki.SearchResult) int {
+	if resultMatchesProject(project, result) {
+		return 0
+	}
+	if strings.HasPrefix(result.Path, "20-wiki/concepts/") && strings.Contains(result.Slug, "conventions") {
+		return 1
+	}
+	if strings.HasPrefix(result.Path, "10-sources/") {
+		return 2
+	}
+	if strings.HasPrefix(result.Path, "20-wiki/concepts/") {
+		return 3
+	}
+	return 4
+}
+
+func isLowSignalHookResult(result wiki.SearchResult) bool {
+	switch strings.ToLower(strings.TrimSpace(result.Type)) {
+	case "index", "log", "schema", "report", "lint-report":
+		return true
+	}
+	switch strings.TrimSpace(result.Path) {
+	case "00-meta/index.md", "00-meta/log.md", "00-meta/AGENTS.md":
+		return true
+	}
+	return false
+}
+
+func suggestedReadTerms(ctx Context) []string {
+	terms := newTermSet()
+	terms.addTerms(ctx.Project.TechTerms...)
+	terms.addText(ctx.Query)
+	for _, field := range strings.Fields(strings.ToLower(ctx.Query)) {
+		terms.addTerm(strings.Trim(field, " \t\r\n`'\"()[]{}:;,!?"))
+	}
+	return terms.values()
+}
+
+func resultIdentityMatchesAnyTerm(result wiki.SearchResult, terms []string) bool {
+	if len(terms) == 0 {
+		return false
+	}
+	identity := strings.ToLower(result.Path + " " + result.Slug + " " + result.Title)
+	tokens := map[string]bool{}
+	for _, token := range tokenSplit.Split(identity, -1) {
+		if token != "" {
+			tokens[token] = true
+		}
+	}
+	for _, term := range terms {
+		term = strings.ToLower(strings.TrimSpace(term))
+		if term == "" {
+			continue
+		}
+		if strings.ContainsAny(term, "+#.") && strings.Contains(identity, term) {
+			return true
+		}
+		if tokens[term] {
+			return true
+		}
+		for _, token := range tokenSplit.Split(term, -1) {
+			if token != "" && tokens[token] {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func writeReadList(b *strings.Builder, results []wiki.SearchResult) {
+	for _, r := range results {
+		fmt.Fprintf(b, "- [[%s]] `%s`", r.Slug, r.Path)
+		if r.Title != "" && r.Title != r.Slug {
+			fmt.Fprintf(b, " — %s", r.Title)
+		}
+		b.WriteString("\n")
+	}
+}
+
+// ExtractCaptureBlock finds the last explicit llm-wiki-capture fenced block in
+// assistant output. This keeps stop-hook persistence opt-in and curated.
+func ExtractCaptureBlock(message string) (CaptureBlock, bool) {
+	marker := "```llm-wiki-capture"
+	start := strings.LastIndex(message, marker)
+	if start < 0 {
+		return CaptureBlock{}, false
+	}
+	bodyStart := start + len(marker)
+	for bodyStart < len(message) && (message[bodyStart] == '\r' || message[bodyStart] == '\n') {
+		bodyStart++
+	}
+	end := strings.Index(message[bodyStart:], "```")
+	if end < 0 {
+		return CaptureBlock{}, false
+	}
+	raw := strings.TrimSpace(message[bodyStart : bodyStart+end])
+	meta, body, ok := strings.Cut(raw, "---")
+	block := CaptureBlock{Body: strings.TrimSpace(raw)}
+	if ok {
+		block.Body = strings.TrimSpace(body)
+		for _, line := range strings.Split(meta, "\n") {
+			key, value, found := strings.Cut(line, ":")
+			if !found {
+				continue
+			}
+			key = strings.TrimSpace(strings.ToLower(key))
+			value = strings.TrimSpace(value)
+			switch key {
+			case "title":
+				block.Title = value
+			case "tags":
+				block.Tags = splitComma(value)
+			}
+		}
+	}
+	if block.Title == "" {
+		block.Title = "Session capture"
+	}
+	return block, strings.TrimSpace(block.Body) != ""
+}
+
+func splitComma(s string) []string {
+	var out []string
+	for _, part := range strings.Split(s, ",") {
+		part = strings.TrimSpace(part)
+		if part != "" {
+			out = append(out, part)
+		}
+	}
+	return out
+}