@m16khb/llm-wiki 0.1.0 → 0.1.1

package/cmd/llm-wiki/main.go

@@ -3,19 +3,24 @@ package main
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"flag"
 	"fmt"
+	"io"
 	"log"
 	"os"
 	"os/signal"
 	"strings"
 	"syscall"
+	"time"
 
 	"github.com/modelcontextprotocol/go-sdk/mcp"
 
 	"github.com/m16khb/llm-wiki/internal/daemon"
+	"github.com/m16khb/llm-wiki/internal/mcpautostart"
 	"github.com/m16khb/llm-wiki/internal/mcpserver"
 	"github.com/m16khb/llm-wiki/internal/service"
+	"github.com/m16khb/llm-wiki/internal/sessionctx"
 	"github.com/m16khb/llm-wiki/internal/store"
 	"github.com/m16khb/llm-wiki/internal/wiki"
 )
@@ -28,8 +33,12 @@ func main() {
 	}
 	cmd := os.Args[1]
 	switch cmd {
+	case "init":
+		runInit(os.Args[2:])
 	case "mcp":
 		runMCP(os.Args[2:])
+	case "mcp-autostart":
+		runMCPAutostart(os.Args[2:])
 	case "serve", "daemon":
 		runServe(os.Args[2:])
 	case "jobs", "queue":
@@ -44,6 +53,14 @@ func main() {
 		runLint(os.Args[2:])
 	case "capture":
 		runCapture(os.Args[2:])
+	case "cleanup":
+		runCleanup(os.Args[2:])
+	case "session-context":
+		runSessionContext(os.Args[2:])
+	case "session-capture":
+		runSessionCapture(os.Args[2:])
+	case "hook":
+		runHook(os.Args[2:])
 	case "version", "--version", "-v":
 		fmt.Println(mcpserver.Version)
 	case "help", "--help", "-h":
@@ -59,14 +76,22 @@ func usage() {
 	fmt.Fprintf(os.Stderr, `llm-wiki %s
 
 Usage:
-  llm-wiki serve [--vault PATH] [--db PATH] [--addr 127.0.0.1:39233]
-  llm-wiki mcp [--vault PATH] [--db PATH]
+	llm-wiki init [--vault PATH] [--json]
+	llm-wiki serve [--vault PATH] [--db PATH] [--addr 127.0.0.1:39233]
+	llm-wiki mcp [--vault PATH] [--db PATH]
+	llm-wiki mcp-autostart [--vault PATH] [--db PATH] [--addr 127.0.0.1:39233]
   llm-wiki info [--vault PATH] [--json]
   llm-wiki search [--vault PATH] [--limit N] [--root FOLDER] QUERY
-  llm-wiki read [--vault PATH] [--max-bytes N] PAGE_OR_PATH
-  llm-wiki lint [--vault PATH] [--json]
-  llm-wiki capture [--vault PATH] [--db PATH] --title TITLE --body BODY [--type concept] [--tags a,b]
-  llm-wiki jobs [--db PATH] [--limit N]
+	llm-wiki read [--vault PATH] [--max-bytes N] PAGE_OR_PATH
+	llm-wiki lint [--vault PATH] [--json]
+	llm-wiki capture [--vault PATH] [--db PATH] --title TITLE --body BODY [--type concept] [--tags a,b]
+	llm-wiki cleanup [--vault PATH] [--scope repository-references|duplicate-slugs] [--archive-root PATH] [--apply] [--json]
+	llm-wiki cleanup analyze [--vault PATH] [--scope repository-references|duplicate-slugs] [--archive-root PATH] [--json]
+	llm-wiki cleanup apply-plan [--vault PATH] --plan FILE [--apply] [--json]
+	llm-wiki session-context [--vault PATH] [--project PATH] [--query TEXT] [--limit N] [--json]
+	llm-wiki session-capture [--vault PATH] [--db PATH] [--project PATH] [--phase progress|end] --body BODY
+	llm-wiki hook [--vault PATH] [--db PATH] [--limit N]
+	llm-wiki jobs [--db PATH] [--limit N]
 
 Environment:
   LLM_WIKI_ROOT or LLM_WIKI_VAULT can provide the default vault path.
@@ -83,6 +108,29 @@ func dbFlag(fs *flag.FlagSet) *string {
 	return fs.String("db", "", "SQLite queue/cache database path")
 }
 
+func runInit(args []string) {
+	fs := flag.NewFlagSet("init", flag.ExitOnError)
+	vaultRoot := vaultFlag(fs)
+	jsonOut := fs.Bool("json", false, "print JSON")
+	_ = fs.Parse(args)
+	result, err := wiki.InitVault(*vaultRoot)
+	must(err)
+	if *jsonOut {
+		printJSON(result)
+		return
+	}
+	fmt.Printf("initialized %s\n", result.Root)
+	if result.CreatedRoot {
+		fmt.Println("created root")
+	}
+	for _, dir := range result.CreatedDirs {
+		fmt.Printf("created %s\n", dir)
+	}
+	if len(result.CreatedDirs) == 0 && !result.CreatedRoot {
+		fmt.Println("standard folders already exist")
+	}
+}
+
 func runMCP(args []string) {
 	fs := flag.NewFlagSet("mcp", flag.ExitOnError)
 	vaultRoot := vaultFlag(fs)
@@ -97,12 +145,33 @@ func runMCP(args []string) {
 	}
 }
 
+func runMCPAutostart(args []string) {
+	fs := flag.NewFlagSet("mcp-autostart", flag.ExitOnError)
+	vaultRoot := vaultFlag(fs)
+	dbPath := dbFlag(fs)
+	addr := fs.String("addr", "127.0.0.1:39233", "HTTP listen address for the shared daemon")
+	startupTimeout := fs.Duration("startup-timeout", 15*time.Second, "maximum time to wait for daemon startup")
+	toolTimeout := fs.Duration("tool-timeout", 60*time.Second, "maximum time for proxied daemon tool calls")
+	initVault := fs.Bool("init-vault", true, "create standard vault folders before starting daemon when missing")
+	_ = fs.Parse(args)
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+	defer stop()
+	if err := mcpautostart.Run(ctx, mcpautostart.Config{VaultRoot: *vaultRoot, DBPath: *dbPath, Addr: *addr, StartupTimeout: *startupTimeout, ToolTimeout: *toolTimeout, InitVault: *initVault}); err != nil {
+		log.Fatalf("llm-wiki mcp-autostart: %v", err)
+	}
+}
+
 func runServe(args []string) {
 	fs := flag.NewFlagSet("serve", flag.ExitOnError)
 	vaultRoot := vaultFlag(fs)
 	dbPath := dbFlag(fs)
 	addr := fs.String("addr", "127.0.0.1:39233", "HTTP listen address for streamable MCP")
+	initVault := fs.Bool("init-vault", false, "create standard vault folders before starting daemon when missing")
 	_ = fs.Parse(args)
+	if *initVault {
+		_, err := wiki.InitVault(*vaultRoot)
+		must(err)
+	}
 	srv, err := daemon.New(daemon.Config{VaultRoot: *vaultRoot, DBPath: *dbPath, Addr: *addr})
 	if err != nil {
 		log.Fatalf("llm-wiki serve: %v", err)
@@ -210,16 +279,242 @@ func runCapture(args []string) {
 	overwrite := fs.Bool("overwrite", false, "overwrite existing page")
 	jsonOut := fs.Bool("json", false, "print JSON")
 	_ = fs.Parse(args)
-	bodyText := *body
-	if *bodyFile != "" {
-		data, err := os.ReadFile(*bodyFile)
+	bodyText, err := readBody(*body, *bodyFile)
+	must(err)
+	svc, err := service.New(service.Config{VaultRoot: *vaultRoot, DBPath: *dbPath})
+	must(err)
+	defer svc.Close()
+	result, err := svc.Capture(wiki.CaptureInput{Title: *title, Body: bodyText, Type: *typ, Status: *status, Domain: *domain, Tags: splitComma(*tags), Folder: *folder, Slug: *slug, Overwrite: *overwrite})
+	must(err)
+	if *jsonOut {
+		printJSON(result)
+		return
+	}
+	fmt.Printf("wrote %s\n", result.Path)
+}
+
+func runCleanup(args []string) {
+	if len(args) > 0 {
+		switch args[0] {
+		case "analyze":
+			runCleanupAnalyze(args[1:])
+			return
+		case "apply-plan":
+			runCleanupApplyPlan(args[1:])
+			return
+		}
+	}
+	fs := flag.NewFlagSet("cleanup", flag.ExitOnError)
+	vaultRoot := vaultFlag(fs)
+	scope := fs.String("scope", "repository-references", "cleanup scope: repository-references or duplicate-slugs")
+	archiveRoot := fs.String("archive-root", "", "vault-relative archive root for moved fragments")
+	apply := fs.Bool("apply", false, "write changes; default is dry-run")
+	jsonOut := fs.Bool("json", false, "print JSON")
+	_ = fs.Parse(args)
+	v := mustVault(*vaultRoot)
+	switch *scope {
+	case "repository-references":
+		result, err := v.CleanupRepositoryReferences(wiki.RepositoryReferenceCleanupOptions{Apply: *apply, ArchiveRoot: *archiveRoot})
 		must(err)
-		bodyText = string(data)
+		if *jsonOut {
+			printJSON(result)
+			return
+		}
+		printRepositoryReferenceCleanup(result)
+	case "duplicate-slugs":
+		result, err := v.CleanupDuplicateSlugs(wiki.DuplicateSlugCleanupOptions{Apply: *apply})
+		must(err)
+		if *jsonOut {
+			printJSON(result)
+			return
+		}
+		printDuplicateSlugCleanup(result)
+	default:
+		must(fmt.Errorf("unsupported cleanup scope: %s", *scope))
+	}
+}
+
+func runCleanupAnalyze(args []string) {
+	fs := flag.NewFlagSet("cleanup analyze", flag.ExitOnError)
+	vaultRoot := vaultFlag(fs)
+	scope := fs.String("scope", "repository-references", "cleanup scope: repository-references or duplicate-slugs")
+	archiveRoot := fs.String("archive-root", "", "vault-relative archive root for moved fragments")
+	jsonOut := fs.Bool("json", false, "print JSON")
+	_ = fs.Parse(args)
+	v := mustVault(*vaultRoot)
+	analysis, err := v.AnalyzeCleanup(wiki.CleanupAnalyzeOptions{Scope: *scope, ArchiveRoot: *archiveRoot})
+	must(err)
+	if *jsonOut {
+		printJSON(analysis)
+		return
+	}
+	printCleanupAnalysis(analysis)
+}
+
+func runCleanupApplyPlan(args []string) {
+	fs := flag.NewFlagSet("cleanup apply-plan", flag.ExitOnError)
+	vaultRoot := vaultFlag(fs)
+	planPath := fs.String("plan", "", "JSON cleanup plan file")
+	apply := fs.Bool("apply", false, "write changes; default is dry-run")
+	jsonOut := fs.Bool("json", false, "print JSON")
+	_ = fs.Parse(args)
+	if strings.TrimSpace(*planPath) == "" {
+		must(errors.New("--plan is required"))
+	}
+	plan, err := readCleanupPlan(*planPath)
+	must(err)
+	v := mustVault(*vaultRoot)
+	result, err := v.ApplyCleanupPlan(wiki.CleanupPlanApplyOptions{Apply: *apply, Plan: plan})
+	must(err)
+	if *jsonOut {
+		printJSON(result)
+		return
+	}
+	printCleanupPlanApply(result)
+}
+
+func readCleanupPlan(path string) (wiki.CleanupPlan, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return wiki.CleanupPlan{}, err
+	}
+	var plan wiki.CleanupPlan
+	if err := json.Unmarshal(data, &plan); err != nil {
+		return wiki.CleanupPlan{}, err
+	}
+	return plan, nil
+}
+
+func printRepositoryReferenceCleanup(result wiki.RepositoryReferenceCleanupResult) {
+	if result.Applied {
+		fmt.Printf("applied %s cleanup: bundles=%d archive=%s\n", result.Scope, len(result.Bundles), result.ArchiveRoot)
+	} else {
+		fmt.Printf("dry-run %s cleanup: bundles=%d archive=%s\n", result.Scope, len(result.Bundles), result.ArchiveRoot)
+		fmt.Println("re-run with --apply to write changes")
+	}
+	for _, bundle := range result.Bundles {
+		fmt.Printf("- %s -> %s (%d fragments)\n", bundle.Repository, bundle.BundlePath, len(bundle.FragmentPaths))
+	}
+	if len(result.SkippedProtectedFiles) > 0 {
+		fmt.Printf("protected files skipped: %d\n", len(result.SkippedProtectedFiles))
+	}
+	if len(result.ReportPaths) > 0 {
+		fmt.Printf("reports: %s\n", strings.Join(result.ReportPaths, ", "))
+	}
+}
+
+func printDuplicateSlugCleanup(result wiki.DuplicateSlugCleanupResult) {
+	if result.Applied {
+		fmt.Printf("applied %s cleanup: renames=%d\n", result.Scope, len(result.Renames))
+	} else {
+		fmt.Printf("dry-run %s cleanup: renames=%d\n", result.Scope, len(result.Renames))
+		fmt.Println("re-run with --apply to write changes")
+	}
+	for _, rename := range result.Renames {
+		fmt.Printf("- %s: %s -> %s (canonical %s)\n", rename.Slug, rename.FromPath, rename.ToPath, rename.CanonicalPath)
+	}
+	if len(result.Warnings) > 0 {
+		fmt.Printf("warnings: %d\n", len(result.Warnings))
+	}
+	if len(result.ReportPaths) > 0 {
+		fmt.Printf("reports: %s\n", strings.Join(result.ReportPaths, ", "))
+	}
+}
+
+func printCleanupAnalysis(result wiki.CleanupAnalysis) {
+	fmt.Printf("analysis %s cleanup: candidates=%d\n", result.Scope, result.CandidateCount)
+	fmt.Println("write a JSON plan, validate with `cleanup apply-plan --plan FILE --json`, then add --apply to write")
+	for _, candidate := range result.Candidates {
+		fmt.Printf("- %s [%s]: %s\n", candidate.ID, candidate.Kind, candidate.Reason)
+		for _, file := range candidate.Files {
+			if file.TargetPath != "" {
+				fmt.Printf("  - %s: %s -> %s\n", file.Role, file.Path, file.TargetPath)
+			} else {
+				fmt.Printf("  - %s: %s\n", file.Role, file.Path)
+			}
+		}
+	}
+	if len(result.Warnings) > 0 {
+		fmt.Printf("warnings: %d\n", len(result.Warnings))
 	}
+}
+
+func printCleanupPlanApply(result wiki.CleanupPlanApplyResult) {
+	if result.Applied {
+		fmt.Printf("applied cleanup plan: actions=%d\n", len(result.Actions))
+	} else {
+		fmt.Printf("dry-run cleanup plan: actions=%d\n", len(result.Actions))
+		fmt.Println("re-run with --apply to write changes")
+	}
+	for _, action := range result.Actions {
+		switch action.Type {
+		case "rename_page":
+			fmt.Printf("- rename_page: %s -> %s\n", action.FromPath, action.ToPath)
+		default:
+			fmt.Printf("- %s %s: planned_changes=%d\n", action.Type, action.Scope, action.PlannedChanges)
+		}
+	}
+	if len(result.ReportPaths) > 0 {
+		fmt.Printf("reports: %s\n", strings.Join(result.ReportPaths, ", "))
+	}
+	if len(result.Warnings) > 0 {
+		fmt.Printf("warnings: %d\n", len(result.Warnings))
+	}
+}
+
+func runSessionContext(args []string) {
+	fs := flag.NewFlagSet("session-context", flag.ExitOnError)
+	vaultRoot := vaultFlag(fs)
+	projectPath := fs.String("project", "", "project root path, default current directory")
+	query := fs.String("query", "", "optional prompt or keywords to combine with project terms")
+	limit := fs.Int("limit", 5, "max wiki matches")
+	jsonOut := fs.Bool("json", false, "print JSON")
+	_ = fs.Parse(args)
+	_, err := wiki.InitVault(*vaultRoot)
+	must(err)
+	v := mustVault(*vaultRoot)
+	ctx, err := sessionctx.BuildContext(v, sessionctx.Options{ProjectPath: *projectPath, Query: *query, Limit: *limit})
+	must(err)
+	if *jsonOut {
+		printJSON(ctx)
+		return
+	}
+	fmt.Print(sessionctx.FormatAdditionalContext(ctx))
+}
+
+func runSessionCapture(args []string) {
+	fs := flag.NewFlagSet("session-capture", flag.ExitOnError)
+	vaultRoot := vaultFlag(fs)
+	dbPath := dbFlag(fs)
+	projectPath := fs.String("project", "", "project root path, default current directory")
+	phase := fs.String("phase", "progress", "session phase such as progress or end")
+	title := fs.String("title", "", "capture title")
+	body := fs.String("body", "", "curated markdown body")
+	bodyFile := fs.String("body-file", "", "read markdown body from file, or - for stdin")
+	tags := fs.String("tags", "", "comma-separated tags")
+	slug := fs.String("slug", "", "optional slug without .md")
+	overwrite := fs.Bool("overwrite", false, "overwrite existing page")
+	jsonOut := fs.Bool("json", false, "print JSON")
+	_ = fs.Parse(args)
+	bodyText, err := readBody(*body, *bodyFile)
+	must(err)
+	project, err := sessionctx.InspectProject(*projectPath)
+	must(err)
+	if *title == "" {
+		*title = "Session " + *phase + ": " + project.Name
+	}
+	allTags := append([]string{"session", strings.TrimSpace(*phase), wiki.Slugify(project.Name)}, splitComma(*tags)...)
+	wikiBody := fmt.Sprintf("## Project\n\n- Name: `%s`\n- Path: `%s`\n- Phase: `%s`\n\n## Capture\n\n%s", project.Name, project.Path, *phase, strings.TrimSpace(bodyText))
+	_, err = wiki.InitVault(*vaultRoot)
+	must(err)
 	svc, err := service.New(service.Config{VaultRoot: *vaultRoot, DBPath: *dbPath})
 	must(err)
 	defer svc.Close()
-	result, err := svc.Capture(wiki.CaptureInput{Title: *title, Body: bodyText, Type: *typ, Status: *status, Domain: *domain, Tags: splitComma(*tags), Folder: *folder, Slug: *slug, Overwrite: *overwrite})
+	captureSlug := *slug
+	if captureSlug == "" {
+		captureSlug = wiki.Slugify(*title) + "-" + time.Now().Format("20060102-150405")
+	}
+	result, err := svc.Capture(wiki.CaptureInput{Title: *title, Body: wikiBody, Type: "session", Status: "active", Domain: "session", Tags: compactStrings(allTags), Slug: captureSlug, Overwrite: *overwrite})
 	must(err)
 	if *jsonOut {
 		printJSON(result)
@@ -228,6 +523,102 @@ func runCapture(args []string) {
 	fmt.Printf("wrote %s\n", result.Path)
 }
 
+type hookInput struct {
+	HookEventName        string `json:"hook_event_name"`
+	CWD                  string `json:"cwd"`
+	Prompt               string `json:"prompt"`
+	LastAssistantMessage string `json:"last_assistant_message"`
+	StopHookActive       bool   `json:"stop_hook_active"`
+}
+
+func runHook(args []string) {
+	fs := flag.NewFlagSet("hook", flag.ExitOnError)
+	vaultRoot := vaultFlag(fs)
+	dbPath := dbFlag(fs)
+	limit := fs.Int("limit", 5, "max wiki matches")
+	_ = fs.Parse(args)
+	data, err := io.ReadAll(os.Stdin)
+	if err != nil {
+		printHookWarning("read hook input: " + err.Error())
+		return
+	}
+	var in hookInput
+	if len(strings.TrimSpace(string(data))) > 0 {
+		if err := json.Unmarshal(data, &in); err != nil {
+			printHookWarning("parse hook input: " + err.Error())
+			return
+		}
+	}
+	event := strings.TrimSpace(in.HookEventName)
+	switch strings.ToLower(event) {
+	case "sessionstart", "session_start":
+		runContextHook(*vaultRoot, in.CWD, "", *limit, firstNonEmptyString(event, "SessionStart"), true)
+	case "userpromptsubmit", "user_prompt_submit":
+		runContextHook(*vaultRoot, in.CWD, in.Prompt, *limit, firstNonEmptyString(event, "UserPromptSubmit"), false)
+	case "stop":
+		runStopHook(*vaultRoot, *dbPath, in)
+	default:
+		printHookJSON(map[string]any{})
+	}
+}
+
+func runContextHook(vaultRoot, projectPath, query string, limit int, event string, includeEmpty bool) {
+	if _, err := wiki.InitVault(vaultRoot); err != nil {
+		printHookWarning("llm-wiki init failed: " + err.Error())
+		return
+	}
+	v, err := wiki.New(vaultRoot)
+	if err != nil {
+		printHookWarning("llm-wiki open failed: " + err.Error())
+		return
+	}
+	ctx, err := sessionctx.BuildContext(v, sessionctx.Options{ProjectPath: projectPath, Query: query, Limit: limit})
+	if err != nil {
+		printHookWarning("llm-wiki context failed: " + err.Error())
+		return
+	}
+	if !includeEmpty && len(ctx.Results) == 0 {
+		printHookJSON(map[string]any{})
+		return
+	}
+	printHookJSON(map[string]any{"hookSpecificOutput": map[string]any{"hookEventName": event, "additionalContext": sessionctx.FormatAdditionalContext(ctx)}})
+}
+
+func runStopHook(vaultRoot, dbPath string, in hookInput) {
+	if in.StopHookActive {
+		printHookJSON(map[string]any{})
+		return
+	}
+	block, ok := sessionctx.ExtractCaptureBlock(in.LastAssistantMessage)
+	if !ok {
+		printHookJSON(map[string]any{})
+		return
+	}
+	project, err := sessionctx.InspectProject(in.CWD)
+	if err != nil {
+		printHookWarning("llm-wiki project inspect failed: " + err.Error())
+		return
+	}
+	if _, err := wiki.InitVault(vaultRoot); err != nil {
+		printHookWarning("llm-wiki init failed: " + err.Error())
+		return
+	}
+	svc, err := service.New(service.Config{VaultRoot: vaultRoot, DBPath: dbPath})
+	if err != nil {
+		printHookWarning("llm-wiki service failed: " + err.Error())
+		return
+	}
+	defer svc.Close()
+	slug := wiki.Slugify(block.Title) + "-" + time.Now().Format("20060102-150405")
+	body := fmt.Sprintf("## Project\n\n- Name: `%s`\n- Path: `%s`\n- Phase: `stop`\n\n## Capture\n\n%s", project.Name, project.Path, strings.TrimSpace(block.Body))
+	result, err := svc.Capture(wiki.CaptureInput{Title: block.Title, Body: body, Type: "session", Status: "active", Domain: "session", Tags: compactStrings(append([]string{"session", "stop", wiki.Slugify(project.Name)}, block.Tags...)), Slug: slug})
+	if err != nil {
+		printHookWarning("llm-wiki capture failed: " + err.Error())
+		return
+	}
+	printHookJSON(map[string]any{"systemMessage": "llm-wiki captured selected session note: " + result.Path})
+}
+
 func runJobs(args []string) {
 	fs := flag.NewFlagSet("jobs", flag.ExitOnError)
 	dbPath := dbFlag(fs)
@@ -260,6 +651,55 @@ func printJSON(v any) {
 	must(enc.Encode(v))
 }
 
+func printHookJSON(v any) {
+	enc := json.NewEncoder(os.Stdout)
+	_ = enc.Encode(v)
+}
+
+func printHookWarning(message string) {
+	printHookJSON(map[string]any{"systemMessage": message})
+}
+
+func readBody(body, bodyFile string) (string, error) {
+	if bodyFile == "" {
+		return body, nil
+	}
+	var data []byte
+	var err error
+	if bodyFile == "-" {
+		data, err = io.ReadAll(os.Stdin)
+	} else {
+		data, err = os.ReadFile(bodyFile)
+	}
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+func compactStrings(values []string) []string {
+	seen := map[string]bool{}
+	out := make([]string, 0, len(values))
+	for _, v := range values {
+		v = strings.TrimSpace(v)
+		if v == "" || seen[v] {
+			continue
+		}
+		seen[v] = true
+		out = append(out, v)
+	}
+	return out
+}
+
+func firstNonEmptyString(values ...string) string {
+	for _, v := range values {
+		if strings.TrimSpace(v) != "" {
+			return v
+		}
+	}
+	return ""
+}
+
 func splitComma(s string) []string {
 	var out []string
 	for _, part := range strings.Split(s, ",") {