init

2026-03-26 12:48:47 +00:00
commit 2d4cff717b
21 changed files with 1835 additions and 0 deletions
--- a/db/alias.go
+++ b/db/alias.go
@@ -0,0 +1,53 @@
+package db
+
+import "errors"
+
+type Alias struct {
+	Name    string
+	Command string
+}
+
+func (db *DB) GetAlias(name string) (*Alias, error) {
+	a := &Alias{}
+	err := db.QueryRow("SELECT name, command FROM aliases WHERE name = ?", name).Scan(&a.Name, &a.Command)
+	if err != nil {
+		return nil, err
+	}
+	return a, nil
+}
+
+func (db *DB) SetAlias(name, command string) error {
+	_, err := db.Exec(
+		"INSERT INTO aliases (name, command) VALUES (?, ?) ON CONFLICT(name) DO UPDATE SET command = excluded.command",
+		name, command,
+	)
+	return err
+}
+
+func (db *DB) DeleteAlias(name string) error {
+	res, err := db.Exec("DELETE FROM aliases WHERE name = ?", name)
+	if err != nil {
+		return err
+	}
+	n, _ := res.RowsAffected()
+	if n == 0 {
+		return errors.New("alias not found")
+	}
+	return nil
+}
+
+func (db *DB) ListAliases() ([]*Alias, error) {
+	rows, err := db.Query("SELECT name, command FROM aliases ORDER BY name")
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var aliases []*Alias
+	for rows.Next() {
+		a := &Alias{}
+		rows.Scan(&a.Name, &a.Command)
+		aliases = append(aliases, a)
+	}
+	return aliases, nil
+}
--- a/db/db.go
+++ b/db/db.go
@@ -0,0 +1,154 @@
+package db
+
+import (
+	"database/sql"
+	"errors"
+	"fmt"
+	"os"
+	"os/user"
+	"path/filepath"
+
+	"axolotl/models"
+
+	_ "modernc.org/sqlite"
+)
+
+type DB struct {
+	*sql.DB
+	path string
+}
+
+var database *DB
+var migrations = []string{
+	`CREATE TABLE IF NOT EXISTS nodes (
+		id TEXT PRIMARY KEY,
+		title TEXT NOT NULL,
+		content TEXT,
+		due_date TEXT,
+		created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+		updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+	)`,
+	`CREATE TABLE IF NOT EXISTS tags (
+		node_id TEXT NOT NULL,
+		tag TEXT NOT NULL,
+		PRIMARY KEY (node_id, tag),
+		FOREIGN KEY (node_id) REFERENCES nodes(id) ON DELETE CASCADE
+	)`,
+	`CREATE TABLE IF NOT EXISTS rels (
+		from_id TEXT NOT NULL,
+		to_id TEXT NOT NULL,
+		rel_type TEXT NOT NULL,
+		PRIMARY KEY (from_id, to_id, rel_type),
+		FOREIGN KEY (from_id) REFERENCES nodes(id) ON DELETE CASCADE,
+		FOREIGN KEY (to_id) REFERENCES nodes(id) ON DELETE CASCADE
+	)`,
+	`CREATE TABLE IF NOT EXISTS aliases (
+		name TEXT PRIMARY KEY,
+		command TEXT NOT NULL
+	)`,
+	`CREATE INDEX IF NOT EXISTS idx_tags_tag ON tags(tag)`,
+	`CREATE INDEX IF NOT EXISTS idx_rels_from ON rels(from_id)`,
+	`CREATE INDEX IF NOT EXISTS idx_rels_to ON rels(to_id)`,
+}
+
+func GetDB() (*DB, error) {
+	if database != nil {
+		return database, nil
+	}
+	dir, err := filepath.Abs(".")
+	if err != nil {
+		return nil, err
+	}
+	for {
+		path := filepath.Join(dir, ".ax.db")
+		if _, err := os.Stat(path); err == nil {
+			database, err = Open(path)
+			if err != nil {
+				return nil, fmt.Errorf("failed to open database: %w", err)
+			}
+			return database, nil
+		}
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			return nil, errors.New("no .ax.db found (run 'ax init' first)")
+		}
+		path = parent
+	}
+}
+
+func Init(path string) (error) {
+	dir := filepath.Dir(path)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return err
+	}
+	var err error
+	database, err = Open(path)
+	return err
+}
+
+func Open(path string) (*DB, error) {
+	database, err := sql.Open("sqlite", path)
+	if err != nil {
+		return nil, err
+	}
+	database.Exec("PRAGMA journal_mode=WAL")
+	database.Exec("PRAGMA busy_timeout=5000")
+	database.Exec("PRAGMA foreign_keys=ON")
+	for _, m := range migrations {
+		if _, err := database.Exec(m); err != nil {
+			return nil, err
+		}
+	}
+	return &DB{DB: database, path: path}, nil
+}
+
+func GetCurrentUser() string {
+	if u := os.Getenv("AX_USER"); u != "" {
+		return u
+	}
+	if u, err := user.Current(); err == nil {
+		return u.Username
+	}
+	return "unknown"
+}
+
+func (db *DB) NodeExists(id string) (bool, error) {
+	var exists bool
+	err := db.QueryRow("SELECT EXISTS(SELECT 1 FROM nodes WHERE id = ?)", id).Scan(&exists)
+	return exists, err
+}
+
+func (db *DB) NodeByID(id string) (*models.Node, error) {
+	n := &models.Node{Relations: make(map[string][]string)}
+	err := db.QueryRow(
+		"SELECT id, title, COALESCE(content, ''), COALESCE(due_date, ''), created_at, updated_at FROM nodes WHERE id = ?",
+		id,
+	).Scan(&n.ID, &n.Title, &n.Content, &n.DueDate, &n.CreatedAt, &n.UpdatedAt)
+	if err != nil {
+		return nil, err
+	}
+
+	rows, err := db.Query("SELECT tag FROM tags WHERE node_id = ?", id)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var tag string
+		rows.Scan(&tag)
+		n.Tags = append(n.Tags, tag)
+	}
+
+	rows, err = db.Query("SELECT to_id, rel_type FROM rels WHERE from_id = ?", id)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var toID, relType string
+		rows.Scan(&toID, &relType)
+		n.Relations[relType] = append(n.Relations[relType], toID)
+	}
+
+	return n, nil
+}
--- a/db/node.go
+++ b/db/node.go
@@ -0,0 +1,358 @@
+package db
+
+import (
+	"axolotl/models"
+	"axolotl/parse"
+	"database/sql"
+	"fmt"
+	"math/rand"
+	"strings"
+	"time"
+)
+
+func generateID() string {
+	const chars = "abcdefghijklmnopqrstuvwxyz"
+	b := make([]byte, 5)
+	for i := range b {
+		b[i] = chars[rand.Intn(26)]
+	}
+	return string(b)
+}
+
+func (db *DB) generateUniqueID() string {
+	//TODO: Check if all ids are reserved
+	for {
+		id := generateID()
+		var exists bool
+		db.QueryRow("SELECT EXISTS(SELECT 1 FROM nodes WHERE id = ?)", id).Scan(&exists)
+		if !exists {
+			return id
+		}
+	}
+}
+
+type CreateParams struct {
+	Title     string
+	Content   string
+	DueDate   string
+	Type      string
+	Status    string
+	Priority  string
+	Namespace string
+	Tags      []string
+	Rels      map[models.RelType][]string
+}
+
+func (db *DB) CreateNode(p CreateParams) (*models.Node, error) {
+	tx, err := db.Begin()
+	if err != nil {
+		return nil, err
+	}
+	defer tx.Rollback()
+
+	now := time.Now().UTC().Format(time.RFC3339)
+	id := db.generateUniqueID()
+
+	_, err = tx.Exec(
+		"INSERT INTO nodes (id, title, content, due_date, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)",
+		id, p.Title, p.Content, p.DueDate, now, now,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	tags := p.Tags
+	if p.Type != "" {
+		tags = append(tags, models.PropertyTag("type", p.Type))
+	} else {
+		tags = append(tags, models.PropertyTag("type", "issue"))
+	}
+	if p.Status != "" {
+		tags = append(tags, models.PropertyTag("status", p.Status))
+	}
+	if p.Priority != "" {
+		tags = append(tags, models.PropertyTag("prio", p.Priority))
+	}
+	ns := p.Namespace
+	if ns == "" {
+		ns = GetCurrentUser()
+	}
+	tags = append(tags, models.PropertyTag("namespace", ns))
+
+	for _, tag := range tags {
+		if _, err := tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, ?)", id, tag); err != nil {
+			return nil, err
+		}
+	}
+
+	for relType, targets := range p.Rels {
+		for _, target := range targets {
+			if _, err := tx.Exec(
+				"INSERT INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)",
+				id, target, relType,
+			); err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	allText := p.Title + " " + p.Content
+	for _, u := range parse.Mentions(allText) {
+		tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, ?)", id, models.PropertyTag("inbox", u))
+	}
+
+	if err := tx.Commit(); err != nil {
+		return nil, err
+	}
+
+	return db.NodeByID(id)
+}
+
+type UpdateParams struct {
+	Title      string
+	Content    string
+	DueDate    string
+	ClearDue   bool
+	Status     string
+	Priority   string
+	AddTags    []string
+	RemoveTags []string
+	AddRels    map[models.RelType][]string
+	RemoveRels map[models.RelType][]string
+}
+
+func (db *DB) UpdateNode(id string, p UpdateParams) error {
+	tx, err := db.Begin()
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+
+	now := time.Now().UTC().Format(time.RFC3339)
+	_, err = tx.Exec("UPDATE nodes SET updated_at = ? WHERE id = ?", now, id)
+	if err != nil {
+		return err
+	}
+
+	if p.Title != "" {
+		_, err = tx.Exec("UPDATE nodes SET title = ? WHERE id = ?", p.Title, id)
+		if err != nil {
+			return err
+		}
+	}
+	if p.Content != "" {
+		_, err = tx.Exec("UPDATE nodes SET content = ? WHERE id = ?", p.Content, id)
+		if err != nil {
+			return err
+		}
+	}
+	if p.DueDate != "" {
+		_, err = tx.Exec("UPDATE nodes SET due_date = ? WHERE id = ?", p.DueDate, id)
+		if err != nil {
+			return err
+		}
+	}
+	if p.ClearDue {
+		_, err = tx.Exec("UPDATE nodes SET due_date = NULL WHERE id = ?", id)
+		if err != nil {
+			return err
+		}
+	}
+
+	for _, tag := range p.AddTags {
+		tx.Exec("INSERT OR IGNORE INTO tags (node_id, tag) VALUES (?, ?)", id, tag)
+	}
+	for _, tag := range p.RemoveTags {
+		tx.Exec("DELETE FROM tags WHERE node_id = ? AND tag = ?", id, tag)
+	}
+
+	if p.Status != "" {
+		tx.Exec("DELETE FROM tags WHERE node_id = ? AND tag LIKE '_status::%'", id)
+		tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, ?)", id, models.PropertyTag("status", p.Status))
+	}
+	if p.Priority != "" {
+		tx.Exec("DELETE FROM tags WHERE node_id = ? AND tag LIKE '_prio::%'", id)
+		tx.Exec("INSERT INTO tags (node_id, tag) VALUES (?, ?)", id, models.PropertyTag("prio", p.Priority))
+	}
+
+	for relType, targets := range p.AddRels {
+		for _, target := range targets {
+			tx.Exec("INSERT OR IGNORE INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)", id, target, relType)
+		}
+	}
+	for relType, targets := range p.RemoveRels {
+		for _, target := range targets {
+			tx.Exec("DELETE FROM rels WHERE from_id = ? AND to_id = ? AND rel_type = ?", id, target, relType)
+		}
+	}
+
+	return tx.Commit()
+}
+
+func (db *DB) DeleteNode(id string) error {
+	_, err := db.Exec("DELETE FROM nodes WHERE id = ?", id)
+	return err
+}
+
+type ListFilter struct {
+	Type      string
+	Status    string
+	Priority  string
+	Namespace string
+	Tag       string
+	Inbox     string
+	Assignee  string
+}
+
+func (db *DB) ListNodes(f ListFilter) ([]*models.Node, error) {
+	q := "SELECT DISTINCT n.id FROM nodes n"
+	args := []interface{}{}
+	joins := []string{}
+	conds := []string{}
+
+	if f.Type != "" {
+		joins = append(joins, "JOIN tags t_type ON n.id = t_type.node_id")
+		conds = append(conds, "t_type.tag = ?")
+		args = append(args, models.PropertyTag("type", f.Type))
+	}
+	if f.Status != "" {
+		joins = append(joins, "JOIN tags t_status ON n.id = t_status.node_id")
+		conds = append(conds, "t_status.tag = ?")
+		args = append(args, models.PropertyTag("status", f.Status))
+	}
+	if f.Priority != "" {
+		joins = append(joins, "JOIN tags t_prio ON n.id = t_prio.node_id")
+		conds = append(conds, "t_prio.tag = ?")
+		args = append(args, models.PropertyTag("prio", f.Priority))
+	}
+	if f.Namespace != "" {
+		joins = append(joins, "JOIN tags t_ns ON n.id = t_ns.node_id")
+		conds = append(conds, "t_ns.tag = ?")
+		args = append(args, models.PropertyTag("namespace", f.Namespace))
+	}
+	if f.Tag != "" {
+		joins = append(joins, "JOIN tags t_tag ON n.id = t_tag.node_id")
+		conds = append(conds, "t_tag.tag = ?")
+		args = append(args, f.Tag)
+	}
+	if f.Inbox != "" {
+		joins = append(joins, "JOIN tags t_inbox ON n.id = t_inbox.node_id")
+		conds = append(conds, "t_inbox.tag = ?")
+		args = append(args, models.PropertyTag("inbox", f.Inbox))
+	}
+	if f.Assignee != "" {
+		joins = append(joins, "JOIN rels r_assign ON n.id = r_assign.from_id")
+		conds = append(conds, "r_assign.to_id = ? AND r_assign.rel_type = ?")
+		args = append(args, f.Assignee, models.RelAssignee)
+	}
+
+	if len(joins) > 0 {
+		q += " " + strings.Join(joins, " ")
+	}
+	if len(conds) > 0 {
+		q += " WHERE " + strings.Join(conds, " AND ")
+	}
+	q += " ORDER BY n.created_at DESC"
+
+	rows, err := db.Query(q, args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var nodes []*models.Node
+	for rows.Next() {
+		var id string
+		if err := rows.Scan(&id); err != nil {
+			return nil, err
+		}
+		n, err := db.NodeByID(id)
+		if err != nil {
+			return nil, err
+		}
+		nodes = append(nodes, n)
+	}
+	return nodes, nil
+}
+
+func (db *DB) CanClose(id string) (bool, []string, error) {
+	rows, err := db.Query(
+		"SELECT to_id FROM rels WHERE from_id = ? AND rel_type = ?",
+		id, models.RelBlocks,
+	)
+	if err != nil {
+		return false, nil, err
+	}
+	defer rows.Close()
+
+	var blocking []string
+	for rows.Next() {
+		var blockerID string
+		if err := rows.Scan(&blockerID); err != nil {
+			return false, nil, err
+		}
+		var tag string
+		err := db.QueryRow(
+			"SELECT tag FROM tags WHERE node_id = ? AND tag LIKE '_status::%'",
+			blockerID,
+		).Scan(&tag)
+		if err == sql.ErrNoRows {
+			blocking = append(blocking, blockerID)
+			continue
+		}
+		if err != nil {
+			return false, nil, err
+		}
+		if strings.HasSuffix(tag, "::open") {
+			blocking = append(blocking, blockerID)
+		}
+	}
+	return len(blocking) == 0, blocking, nil
+}
+
+func (db *DB) GetAllUsers() ([]string, error) {
+	rows, err := db.Query("SELECT n.id FROM nodes n JOIN tags t ON n.id = t.node_id WHERE t.tag = ?", models.PropertyTag("type", "user"))
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var users []string
+	for rows.Next() {
+		var id string
+		rows.Scan(&id)
+		users = append(users, id)
+	}
+	return users, nil
+}
+
+func (db *DB) GetSubtasks(parentID string) ([]*models.Node, error) {
+	rows, err := db.Query(
+		"SELECT to_id FROM rels WHERE from_id = ? AND rel_type = ?",
+		parentID, models.RelSubtask,
+	)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var nodes []*models.Node
+	for rows.Next() {
+		var id string
+		rows.Scan(&id)
+		n, err := db.NodeByID(id)
+		if err != nil {
+			return nil, err
+		}
+		nodes = append(nodes, n)
+	}
+	return nodes, nil
+}
+
+func ParseRelFlag(s string) (models.RelType, string, error) {
+	parts := strings.SplitN(s, ":", 2)
+	if len(parts) != 2 {
+		return "", "", fmt.Errorf("invalid relation format: %s (expected type:id)", s)
+	}
+	return models.RelType(parts[0]), parts[1], nil
+}
--- a/db/rel.go
+++ b/db/rel.go
@@ -0,0 +1,57 @@
+package db
+
+import "axolotl/models"
+
+func (db *DB) AddRel(fromID, toID string, relType models.RelType) error {
+	_, err := db.Exec(
+		"INSERT OR IGNORE INTO rels (from_id, to_id, rel_type) VALUES (?, ?, ?)",
+		fromID, toID, relType,
+	)
+	return err
+}
+
+func (db *DB) RemoveRel(fromID, toID string, relType models.RelType) error {
+	_, err := db.Exec(
+		"DELETE FROM rels WHERE from_id = ? AND to_id = ? AND rel_type = ?",
+		fromID, toID, relType,
+	)
+	return err
+}
+
+func (db *DB) GetRelated(id string, relType models.RelType) ([]string, error) {
+	rows, err := db.Query(
+		"SELECT to_id FROM rels WHERE from_id = ? AND rel_type = ?",
+		id, relType,
+	)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var ids []string
+	for rows.Next() {
+		var target string
+		rows.Scan(&target)
+		ids = append(ids, target)
+	}
+	return ids, nil
+}
+
+func (db *DB) GetIncomingRels(id string, relType models.RelType) ([]string, error) {
+	rows, err := db.Query(
+		"SELECT from_id FROM rels WHERE to_id = ? AND rel_type = ?",
+		id, relType,
+	)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var ids []string
+	for rows.Next() {
+		var source string
+		rows.Scan(&source)
+		ids = append(ids, source)
+	}
+	return ids, nil
+}