ALL='["backup","blobs","bookmarks","cellar","easel","feeds","habbits","jotts","kepler","library","og","posts","quotes","shrink","sipp"]'

          for app in backup blobs bookmarks cellar easel feeds habbits jotts kepler library og posts quotes shrink sipp; do

          ALL='["backup","blobs","bookmarks","cellar","easel","feeds","habbits","jotts","kepler","library","og","posts","quotes","shrink","sipp"]'

          for app in backup blobs bookmarks cellar easel feeds habbits jotts kepler library og posts quotes shrink sipp; do

apps/habbits/habbits

Automated SQLite backups for Jotts, Sipp, Cellar, Posts, Feeds, Library, Bookmarks, Parcels, Easel, and Habbits to Cloudflare R2. Runs every 6 hours via cron inside a Docker container and prunes backups older than 30 days.

HABBITS_VOLUME=habbits_habbits-data

  -v habbits_habbits-data:/data/habbits:ro \

- `<app>` — one of: `jotts sipp cellar posts feeds library bookmarks parcels easel habbits`, or `all`.

| `HABBITS_VOLUME` | `habbits_habbits-data` | Docker volume name for Habbits data |

DBS="jotts:/data/jotts/jotts.sqlite sipp:/data/sipp/sipp.sqlite cellar:/data/cellar/cellar.sqlite posts:/data/posts/posts.sqlite feeds:/data/feeds/feeds.sqlite library:/data/library/library.sqlite bookmarks:/data/bookmarks/bookmarks.sqlite parcels:/data/parcels/parcels.db easel:/data/easel/easel.sqlite habbits:/data/habbits/habbits.sqlite"

for name in jotts sipp cellar posts feeds library bookmarks parcels easel habbits; do

      - habbits-data:/data/habbits:ro

  habbits-data:

    external: true

    name: ${HABBITS_VOLUME:-habbits_habbits-data}

easel:easel.sqlite:easel_data:easel_easel-data

habbits:habbits.sqlite:habbits_data:habbits_habbits-data"

HABBITS_PASSWORD=changeme

HABBITS_API_KEY=

HABBITS_DB_PATH=habbits.sqlite

HOST=0.0.0.0

PORT=3000

BASE_URL=http://localhost:3000

COOKIE_SECURE=false

# Build from repo root: docker build -t habbits -f apps/habbits/Dockerfile .

FROM golang:1.24-bookworm AS builder

WORKDIR /app

COPY pkg/ ./pkg/

COPY apps/habbits/go.mod apps/habbits/go.sum ./apps/habbits/

WORKDIR /app/apps/habbits

RUN go mod download

COPY apps/habbits/ ./

RUN CGO_ENABLED=0 go build -o /habbits .

FROM debian:bookworm-slim

RUN apt-get update && apt-get install -y ca-certificates && rm -rf /var/lib/apt/lists/*

COPY --from=builder /habbits /usr/local/bin/habbits

WORKDIR /data

ENV HOST=0.0.0.0

ENV PORT=3000

EXPOSE 3000

CMD ["habbits"]

# habbits

A minimal, single-admin habit tracker. Define custom habits (each with a typed

value) and log records against them over time. The whole app is behind a

session login — there are no public pages.

## Concepts

- **Habit** — something you track. Has a `name`, a `value_type`

  (`int` | `float` | `bool` | `string`), and optional `unit` and `description`.

- **Record** — a single data point for a habit: a `value` (validated against the

  habit's type) and a `recorded_at` timestamp. The timestamp auto-fills to the

  current time on entry but can be edited/backdated in the UI.

## Routes

Web (all require a session except the login flow):

| Method | Path | Description |

| ------ | ---- | ----------- |

| GET  | `/login` / `/logout`            | Session login / logout |

| GET  | `/`                             | Dashboard: create habit, add record, recent activity |

| POST | `/habits`                       | Create a habit |

| GET  | `/habits/{short_id}`            | Habit detail: edit habit + its records |

| POST | `/habits/{short_id}`            | Update a habit |

| POST | `/habits/{short_id}/delete`     | Delete a habit (cascades its records) |

| POST | `/records`                      | Create a record |

| POST | `/records/{short_id}`           | Update a record |

| POST | `/records/{short_id}/delete`    | Delete a record |

Read-only JSON API (requires `X-API-Key` header; disabled when `HABBITS_API_KEY`

is empty):

| Method | Path | Description |

| ------ | ---- | ----------- |

| GET | `/api/habits`            | All habits |

| GET | `/api/records?limit=100` | Recent records (max 500) |

## Configuration

Copy the values below into `apps/habbits/.env` (create the file locally; it is

git-ignored):

```

HABBITS_PASSWORD=changeme        # admin password (plaintext or bcrypt hash); empty disables login

HABBITS_API_KEY=                 # optional; enables the read-only JSON API when set

HABBITS_DB_PATH=habbits.sqlite   # SQLite file path

HOST=0.0.0.0

PORT=3000

BASE_URL=http://localhost:3000

COOKIE_SECURE=false              # set true behind HTTPS

```

## Development

```

cd apps/habbits

go mod tidy

go run .          # serves on $HOST:$PORT

```

Or with Docker (built from repo root):

```

docker build -t habbits -f apps/habbits/Dockerfile .

```

package main

import (

	"database/sql"

	"embed"

	"html/template"

	"log/slog"

	"github.com/stevedylandev/andromeda/pkg/auth"

)

//go:embed templates/*.html static/*

var appFS embed.FS

type App struct {

	DB            *sql.DB

	Log           *slog.Logger

	Templates     *template.Template

	Sessions      *auth.Store

	AdminPassword string

	APIKey        string

	CookieSecure  bool

	BaseURL       string

}

// valueTypes is the fixed set of value types a habit may declare. Kept in sync

// with the CHECK constraint in habbitsSchema and the normalizeValue switch.

var valueTypes = []string{"int", "float", "bool", "string"}

// habitRow is the view model for a habit in list/detail templates.

type habitRow struct {

	ShortID     string

	Name        string

	ValueType   string

	Unit        string

	Description string

	RecordCount int

}

// recordRow is the view model for a record. Date is the grouping key

// (YYYY-MM-DD); TimeDisplay is the time-of-day shown within a day group;

// RecordedAtInput is the datetime-local value for edit forms.

type recordRow struct {

	ShortID         string

	HabitShortID    string

	HabitName       string

	ValueType       string

	Value           string

	Unit            string

	Date            string

	TimeDisplay     string

	RecordedAtInput string

}

// dashDay groups a day's records by habit for the dashboard (day -> habit -> records).

type dashDay struct {

	Date   string

	Habits []dashHabit

}

type dashHabit struct {

	HabitName    string

	HabitShortID string

	ValueType    string

	Unit         string

	Records      []recordRow

}

// habitDay groups a single habit's records by day for the habit detail page.

type habitDay struct {

	Date    string

	Records []recordRow

}

type loginPageData struct {

	Error string

}

type dashboardData struct {

	Success string

	Error   string

	Habits  []habitRow

	Days    []dashDay

}

type newHabitPageData struct {

	Error      string

	ValueTypes []string

}

type settingsPageData struct {

	Success    string

	Error      string

	ValueTypes []string

	Habits     []habitRow

}

type habitPageData struct {

	Success string

	Error   string

	Habit   habitRow

	Days    []habitDay

}

package main

import (

	"database/sql"

	"errors"

	"strings"

	"time"

	"github.com/stevedylandev/andromeda/pkg/auth"

)

const habbitsSchema = `

CREATE TABLE IF NOT EXISTS habits (

    id          INTEGER PRIMARY KEY AUTOINCREMENT,

    short_id    TEXT NOT NULL UNIQUE,

    name        TEXT NOT NULL,

    value_type  TEXT NOT NULL CHECK(value_type IN ('int','float','bool','string')),

    unit        TEXT,

    description TEXT,

    created_at  INTEGER NOT NULL,

    updated_at  INTEGER NOT NULL

);

CREATE TABLE IF NOT EXISTS records (

    id          INTEGER PRIMARY KEY AUTOINCREMENT,

    short_id    TEXT NOT NULL UNIQUE,

    habit_id    INTEGER NOT NULL REFERENCES habits(id) ON DELETE CASCADE,

    value       TEXT NOT NULL,

    recorded_at INTEGER NOT NULL,

    created_at  INTEGER NOT NULL,

    updated_at  INTEGER NOT NULL

);

CREATE INDEX IF NOT EXISTS idx_records_habit ON records(habit_id, recorded_at DESC);

`

type Habit struct {

	ID          int64   `json:"id"`

	ShortID     string  `json:"short_id"`

	Name        string  `json:"name"`

	ValueType   string  `json:"value_type"`

	Unit        *string `json:"unit,omitempty"`

	Description *string `json:"description,omitempty"`

	CreatedAt   int64   `json:"created_at"`

	UpdatedAt   int64   `json:"updated_at"`

}

type Record struct {

	ID         int64  `json:"id"`

	ShortID    string `json:"short_id"`

	HabitID    int64  `json:"habit_id"`

	Value      string `json:"value"`

	RecordedAt int64  `json:"recorded_at"`

	CreatedAt  int64  `json:"created_at"`

	UpdatedAt  int64  `json:"updated_at"`

	// Populated by joined queries; not stored on the records table.

	HabitShortID string `json:"habit_short_id,omitempty"`

	HabitName    string `json:"habit_name,omitempty"`

	ValueType    string `json:"value_type,omitempty"`

	Unit         string `json:"unit,omitempty"`

}

const habitCols = `id, short_id, name, value_type, unit, description, created_at, updated_at`

func scanHabit(s interface{ Scan(...any) error }) (*Habit, error) {

	var h Habit

	var unit, desc sql.NullString

	err := s.Scan(&h.ID, &h.ShortID, &h.Name, &h.ValueType, &unit, &desc, &h.CreatedAt, &h.UpdatedAt)

	if errors.Is(err, sql.ErrNoRows) {

		return nil, nil

	}

	if err != nil {

		return nil, err

	}

	if unit.Valid {

		v := unit.String

		h.Unit = &v

	}

	if desc.Valid {

		v := desc.String

		h.Description = &v

	}

	return &h, nil

}

// listHabits returns all habits ordered by name, each annotated with its record

// count via a LEFT JOIN so habits with zero records still appear.

func listHabits(db *sql.DB) ([]Habit, map[int64]int, error) {

	rows, err := db.Query(`

		SELECT ` + prefixCols("h", habitCols) + `, COUNT(r.id)

		FROM habits h

		LEFT JOIN records r ON r.habit_id = h.id

		GROUP BY h.id

		ORDER BY h.name COLLATE NOCASE ASC`)

	if err != nil {

		return nil, nil, err

	}

	defer rows.Close()

	var out []Habit

	counts := map[int64]int{}

	for rows.Next() {

		var h Habit

		var unit, desc sql.NullString

		var count int

		if err := rows.Scan(&h.ID, &h.ShortID, &h.Name, &h.ValueType, &unit, &desc, &h.CreatedAt, &h.UpdatedAt, &count); err != nil {

			return nil, nil, err

		}

		if unit.Valid {

			v := unit.String

			h.Unit = &v

		}

		if desc.Valid {

			v := desc.String

			h.Description = &v

		}

		out = append(out, h)

		counts[h.ID] = count

	}

	return out, counts, rows.Err()

}

func getHabitByShortID(db *sql.DB, shortID string) (*Habit, error) {

	return scanHabit(db.QueryRow(`SELECT `+habitCols+` FROM habits WHERE short_id = ?`, shortID))

}

func insertHabit(db *sql.DB, name, valueType, unit, description string) (int64, error) {

	shortID, err := auth.GenerateShortID(10)

	if err != nil {

		return 0, err

	}

	now := time.Now().UTC().Unix()

	res, err := db.Exec(

		`INSERT INTO habits (short_id, name, value_type, unit, description, created_at, updated_at)

		 VALUES (?, ?, ?, ?, ?, ?, ?)`,

		shortID, name, valueType, nullify(unit), nullify(description), now, now,

	)

	if err != nil {

		return 0, err

	}

	return res.LastInsertId()

}

func updateHabit(db *sql.DB, shortID, name, valueType, unit, description string) error {

	_, err := db.Exec(

		`UPDATE habits SET name = ?, value_type = ?, unit = ?, description = ?, updated_at = ?

		 WHERE short_id = ?`,

		name, valueType, nullify(unit), nullify(description), time.Now().UTC().Unix(), shortID,

	)

	return err

}

func deleteHabitByShortID(db *sql.DB, shortID string) error {

	_, err := db.Exec(`DELETE FROM habits WHERE short_id = ?`, shortID)

	return err

}

const recordJoin = `

	SELECT r.id, r.short_id, r.habit_id, r.value, r.recorded_at, r.created_at, r.updated_at,

	       h.short_id, h.name, h.value_type, IFNULL(h.unit,'')

	FROM records r JOIN habits h ON h.id = r.habit_id`

func scanRecordJoined(s interface{ Scan(...any) error }) (*Record, error) {

	var r Record

	err := s.Scan(&r.ID, &r.ShortID, &r.HabitID, &r.Value, &r.RecordedAt, &r.CreatedAt, &r.UpdatedAt,

		&r.HabitShortID, &r.HabitName, &r.ValueType, &r.Unit)

	if errors.Is(err, sql.ErrNoRows) {

		return nil, nil

	}

	if err != nil {

		return nil, err

	}

	return &r, nil

}

func queryRecords(db *sql.DB, where string, args ...any) ([]Record, error) {

	rows, err := db.Query(recordJoin+" "+where, args...)

	if err != nil {

		return nil, err

	}

	defer rows.Close()

	var out []Record

	for rows.Next() {

		rec, err := scanRecordJoined(rows)

		if err != nil {

			return nil, err

		}

		out = append(out, *rec)

	}

	return out, rows.Err()

}

func listRecords(db *sql.DB, limit int) ([]Record, error) {

	return queryRecords(db, `ORDER BY r.recorded_at DESC, r.id DESC LIMIT ?`, limit)

}

func listRecordsForHabit(db *sql.DB, habitID int64) ([]Record, error) {

	return queryRecords(db, `WHERE r.habit_id = ? ORDER BY r.recorded_at DESC, r.id DESC`, habitID)

}

func getRecordByShortID(db *sql.DB, shortID string) (*Record, error) {

	return scanRecordJoined(db.QueryRow(recordJoin+` WHERE r.short_id = ?`, shortID))

}

// recordsForExport returns records in chronological order for CSV export. When

// habitShortID is non-empty, only that habit's records are returned.

func recordsForExport(db *sql.DB, habitShortID string) ([]Record, error) {

	if habitShortID != "" {

		return queryRecords(db, `WHERE h.short_id = ? ORDER BY r.recorded_at ASC, r.id ASC`, habitShortID)

	}

	return queryRecords(db, `ORDER BY r.recorded_at ASC, r.id ASC`)

}

func insertRecord(db *sql.DB, habitID int64, value string, recordedAt int64) (int64, error) {

	shortID, err := auth.GenerateShortID(10)

	if err != nil {

		return 0, err

	}

	now := time.Now().UTC().Unix()

	res, err := db.Exec(

		`INSERT INTO records (short_id, habit_id, value, recorded_at, created_at, updated_at)

		 VALUES (?, ?, ?, ?, ?, ?)`,

		shortID, habitID, value, recordedAt, now, now,

	)

	if err != nil {

		return 0, err

	}

	return res.LastInsertId()

}

func updateRecord(db *sql.DB, shortID, value string, recordedAt int64) error {

	_, err := db.Exec(

		`UPDATE records SET value = ?, recorded_at = ?, updated_at = ? WHERE short_id = ?`,

		value, recordedAt, time.Now().UTC().Unix(), shortID,

	)

	return err

}

func deleteRecordByShortID(db *sql.DB, shortID string) error {

	_, err := db.Exec(`DELETE FROM records WHERE short_id = ?`, shortID)

	return err

}

// nullify returns nil for empty/whitespace strings so they store as SQL NULL.

func nullify(s string) any {

	if strings.TrimSpace(s) == "" {

		return nil

	}

	return s

}

// prefixCols rewrites a comma column list like "id, short_id" into

// "h.id, h.short_id" for use in JOIN selects.

func prefixCols(alias, cols string) string {

	parts := strings.Split(cols, ",")

	for i, p := range parts {

		parts[i] = " " + alias + "." + strings.TrimSpace(p)

	}

	return strings.Join(parts, ",")

}

services:

  app:

    build:

      context: ../..

      dockerfile: apps/habbits/Dockerfile

    ports:

      - "${PORT:-3000}:${PORT:-3000}"

    environment:

      - HOST=0.0.0.0

      - PORT=${PORT:-3000}

      - HABBITS_DB_PATH=/data/habbits.sqlite

      - HABBITS_PASSWORD=${HABBITS_PASSWORD:-changeme}

      - HABBITS_API_KEY=${HABBITS_API_KEY:-}

      - BASE_URL=${BASE_URL:-http://localhost:${PORT:-3000}}

      - COOKIE_SECURE=${COOKIE_SECURE:-false}

    volumes:

      - habbits-data:/data

    restart: unless-stopped

volumes:

  habbits-data:

module github.com/stevedylandev/andromeda/apps/habbits

go 1.24.4

require (

	github.com/stevedylandev/andromeda/pkg/auth v0.0.0

	github.com/stevedylandev/andromeda/pkg/config v0.0.0

	github.com/stevedylandev/andromeda/pkg/darkmatter v0.0.0

	github.com/stevedylandev/andromeda/pkg/sqlite v0.0.0

	github.com/stevedylandev/andromeda/pkg/web v0.0.0

)

require (

	github.com/dustin/go-humanize v1.0.1 // indirect

	github.com/google/uuid v1.6.0 // indirect

	github.com/mattn/go-isatty v0.0.20 // indirect

	github.com/ncruces/go-strftime v0.1.9 // indirect

	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect

	golang.org/x/crypto v0.39.0 // indirect

	golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 // indirect

	golang.org/x/sys v0.33.0 // indirect

	modernc.org/libc v1.65.7 // indirect

	modernc.org/mathutil v1.7.1 // indirect

	modernc.org/memory v1.11.0 // indirect

	modernc.org/sqlite v1.37.1 // indirect

)

replace (

	github.com/stevedylandev/andromeda/pkg/auth => ../../pkg/auth

	github.com/stevedylandev/andromeda/pkg/config => ../../pkg/config

	github.com/stevedylandev/andromeda/pkg/darkmatter => ../../pkg/darkmatter

	github.com/stevedylandev/andromeda/pkg/sqlite => ../../pkg/sqlite

	github.com/stevedylandev/andromeda/pkg/web => ../../pkg/web

)

github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=

github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=

github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs=

github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=

github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=

github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=

github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=

github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=

github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=

github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=

github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=

github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=

golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM=

golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U=

golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 h1:R84qjqJb5nVJMxqWYb3np9L5ZsaDtB+a39EqjV0JSUM=

golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0/go.mod h1:S9Xr4PYopiDyqSyp5NjCrhFrqg6A5zA2E/iPHPhqnS8=

golang.org/x/mod v0.24.0 h1:ZfthKaKaT4NrhGVZHO1/WDTwGES4De8KtWO0SIbNJMU=

golang.org/x/mod v0.24.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=

golang.org/x/sync v0.14.0 h1:woo0S4Yywslg6hp4eUFjTVOyKt0RookbpAHG4c1HmhQ=

golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=

golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=

golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=

golang.org/x/tools v0.33.0 h1:4qz2S3zmRxbGIhDIAgjxvFutSvH5EfnsYrRBj0UI0bc=

golang.org/x/tools v0.33.0/go.mod h1:CIJMaWEY88juyUfo7UbgPqbC8rU2OqfAV1h2Qp0oMYI=

modernc.org/cc/v4 v4.26.1 h1:+X5NtzVBn0KgsBCBe+xkDC7twLb/jNVj9FPgiwSQO3s=

modernc.org/cc/v4 v4.26.1/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=

modernc.org/ccgo/v4 v4.28.0 h1:rjznn6WWehKq7dG4JtLRKxb52Ecv8OUGah8+Z/SfpNU=

modernc.org/ccgo/v4 v4.28.0/go.mod h1:JygV3+9AV6SmPhDasu4JgquwU81XAKLd3OKTUDNOiKE=

modernc.org/fileutil v1.3.1 h1:8vq5fe7jdtEvoCf3Zf9Nm0Q05sH6kGx0Op2CPx1wTC8=

modernc.org/fileutil v1.3.1/go.mod h1:HxmghZSZVAz/LXcMNwZPA/DRrQZEVP9VX0V4LQGQFOc=

modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI=

modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito=

modernc.org/libc v1.65.7 h1:Ia9Z4yzZtWNtUIuiPuQ7Qf7kxYrxP1/jeHZzG8bFu00=

modernc.org/libc v1.65.7/go.mod h1:011EQibzzio/VX3ygj1qGFt5kMjP0lHb0qCW5/D/pQU=

modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=

modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=

modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI=

modernc.org/memory v1.11.0/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw=

modernc.org/opt v0.1.4 h1:2kNGMRiUjrp4LcaPuLY2PzUfqM/w9N23quVwhKt5Qm8=

modernc.org/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=

modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=

modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=

modernc.org/sqlite v1.37.1 h1:EgHJK/FPoqC+q2YBXg7fUmES37pCHFc97sI7zSayBEs=

modernc.org/sqlite v1.37.1/go.mod h1:XwdRtsE1MpiBcL54+MbKcaDvcuej+IYSMfLN6gSKV8g=

modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0=

modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A=

modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=

modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=

package main

import (

	"net/http"

	"strconv"

	"github.com/stevedylandev/andromeda/pkg/web"

)

func (a *App) apiListHabits(w http.ResponseWriter, r *http.Request) {

	habits, _, err := listHabits(a.DB)

	if err != nil {

		a.Log.Error("api list habits", "err", err)

		web.WriteError(w, http.StatusInternalServerError, "internal error")

		return

	}

	if habits == nil {

		habits = []Habit{}

	}

	web.WriteJSON(w, http.StatusOK, habits)

}

func (a *App) apiListRecords(w http.ResponseWriter, r *http.Request) {

	limit := 100

	if v := r.URL.Query().Get("limit"); v != "" {

		if n, err := strconv.Atoi(v); err == nil && n > 0 && n <= 500 {

			limit = n

		}

	}

	records, err := listRecords(a.DB, limit)

	if err != nil {

		a.Log.Error("api list records", "err", err)

		web.WriteError(w, http.StatusInternalServerError, "internal error")

		return

	}

	if records == nil {

		records = []Record{}

	}

	web.WriteJSON(w, http.StatusOK, records)

}

package main

import (

	"encoding/csv"

	"net/http"

	"strings"

	"time"

	"github.com/stevedylandev/andromeda/pkg/web"

)

// exportHandler streams records as CSV. With ?habit=<short_id> it exports a

// single habit; otherwise every habit's records. Rows are chronological.

func (a *App) exportHandler(w http.ResponseWriter, r *http.Request) {

	habitShortID := strings.TrimSpace(r.URL.Query().Get("habit"))

	filename := "habbits-export.csv"

	if habitShortID != "" {

		habit, err := getHabitByShortID(a.DB, habitShortID)

		if err != nil {

			a.Log.Error("export get habit", "err", err)

			web.RedirectWithError(w, r, "/settings", "Failed to export")

			return

		}

		if habit == nil {

			http.NotFound(w, r)

			return

		}

		filename = "habbits-" + slugify(habit.Name) + ".csv"

	}

	records, err := recordsForExport(a.DB, habitShortID)

	if err != nil {

		a.Log.Error("export records", "err", err)

		web.RedirectWithError(w, r, "/settings", "Failed to export")

		return

	}

	w.Header().Set("Content-Type", "text/csv; charset=utf-8")

	w.Header().Set("Content-Disposition", `attachment; filename="`+filename+`"`)

	cw := csv.NewWriter(w)

	_ = cw.Write([]string{"recorded_at", "habit", "value_type", "unit", "value"})

	for _, rec := range records {

		_ = cw.Write([]string{

			time.Unix(rec.RecordedAt, 0).Local().Format(time.RFC3339),

			rec.HabitName,

			rec.ValueType,

			rec.Unit,

			rec.Value,

		})

	}

	cw.Flush()

	if err := cw.Error(); err != nil {

		a.Log.Error("export csv write", "err", err)

	}

}

// slugify makes a filesystem-safe token from a habit name for the download

// filename, e.g. "Sleep hours" -> "sleep-hours".

func slugify(s string) string {

	var b strings.Builder

	prevDash := false

	for _, r := range strings.ToLower(strings.TrimSpace(s)) {

		switch {

		case r >= 'a' && r <= 'z', r >= '0' && r <= '9':

			b.WriteRune(r)

			prevDash = false

		default:

			if !prevDash && b.Len() > 0 {

				b.WriteByte('-')

				prevDash = true

			}

		}

	}

	out := strings.Trim(b.String(), "-")

	if out == "" {

		return "habit"

	}

	return out

}

package main

import (

	"net/http"

	"strings"

	"time"

	"github.com/stevedylandev/andromeda/pkg/auth"

	"github.com/stevedylandev/andromeda/pkg/web"

)

const (

	dateLayout  = "2006-01-02"

	timeLayout  = "15:04"

	inputLayout = "2006-01-02T15:04" // datetime-local

)

func habitToRow(h Habit, count int) habitRow {

	row := habitRow{ShortID: h.ShortID, Name: h.Name, ValueType: h.ValueType, RecordCount: count}

	if h.Unit != nil {

		row.Unit = *h.Unit

	}

	if h.Description != nil {

		row.Description = *h.Description

	}

	return row

}

func recordToRow(r Record) recordRow {

	t := time.Unix(r.RecordedAt, 0).Local()

	return recordRow{

		ShortID:         r.ShortID,

		HabitShortID:    r.HabitShortID,

		HabitName:       r.HabitName,

		ValueType:       r.ValueType,

		Value:           r.Value,

		Unit:            r.Unit,

		Date:            t.Format(dateLayout),

		TimeDisplay:     t.Format(timeLayout),

		RecordedAtInput: t.Format(inputLayout),

	}

}

// groupDashboard buckets records (ordered recorded_at DESC) into day groups,

// and within each day into per-habit groups, preserving encounter order.

func groupDashboard(recs []Record) []dashDay {

	var days []dashDay

	dayIdx := map[string]int{}

	habitIdx := map[string]map[string]int{}

	for _, r := range recs {

		row := recordToRow(r)

		di, ok := dayIdx[row.Date]

		if !ok {

			di = len(days)

			dayIdx[row.Date] = di

			habitIdx[row.Date] = map[string]int{}

			days = append(days, dashDay{Date: row.Date})

		}

		hi, ok := habitIdx[row.Date][r.HabitShortID]

		if !ok {

			hi = len(days[di].Habits)

			habitIdx[row.Date][r.HabitShortID] = hi

			days[di].Habits = append(days[di].Habits, dashHabit{

				HabitName:    r.HabitName,

				HabitShortID: r.HabitShortID,

				ValueType:    r.ValueType,

				Unit:         r.Unit,

			})

		}

		days[di].Habits[hi].Records = append(days[di].Habits[hi].Records, row)

	}

	return days

}

// groupByDay buckets a single habit's records (ordered recorded_at DESC) into

// day groups, preserving encounter order.

func groupByDay(recs []Record) []habitDay {

	var days []habitDay

	idx := map[string]int{}

	for _, r := range recs {

		row := recordToRow(r)

		i, ok := idx[row.Date]

		if !ok {

			i = len(days)

			idx[row.Date] = i

			days = append(days, habitDay{Date: row.Date})

		}

		days[i].Records = append(days[i].Records, row)

	}

	return days

}

// parseRecordedAt converts a datetime-local form value into unix seconds. An

// empty value defaults to now, matching the "auto-injected at time of entry"

// behaviour while still allowing a backdated entry from the UI.

func parseRecordedAt(raw string) (int64, error) {

	raw = strings.TrimSpace(raw)

	if raw == "" {

		return time.Now().Unix(), nil

	}

	t, err := time.ParseInLocation(inputLayout, raw, time.Local)

	if err != nil {

		return 0, err

	}

	return t.Unix(), nil

}

// --- auth ---

func (a *App) loginGetHandler(w http.ResponseWriter, r *http.Request) {

	web.Render(a.Templates, w, "login.html", loginPageData{Error: r.URL.Query().Get("error")}, a.Log)

}

func (a *App) loginPostHandler(w http.ResponseWriter, r *http.Request) {

	if a.AdminPassword == "" {

		web.RedirectWithError(w, r, "/login", "No admin password configured")

		return

	}

	if err := r.ParseForm(); err != nil {

		web.RedirectWithError(w, r, "/login", "Bad request")

		return

	}

	if !auth.VerifyPassword(r.FormValue("password"), a.AdminPassword) {

		web.RedirectWithError(w, r, "/login", "Invalid password")

		return

	}

	token, err := a.Sessions.Create()

	if err != nil {

		a.Log.Error("create session failed", "err", err)

		web.RedirectWithError(w, r, "/login", "Session error")

		return

	}

	a.Sessions.PruneExpired()

	http.SetCookie(w, a.Sessions.SessionCookie(token))

	http.Redirect(w, r, "/", http.StatusSeeOther)

}

func (a *App) logoutHandler(w http.ResponseWriter, r *http.Request) {

	if c, err := r.Cookie(a.Sessions.CookieName); err == nil && c.Value != "" {

		a.Sessions.Delete(c.Value)

	}

	http.SetCookie(w, a.Sessions.ClearCookie())

	http.Redirect(w, r, "/login", http.StatusSeeOther)

}

// --- dashboard ---

func (a *App) dashboardHandler(w http.ResponseWriter, r *http.Request) {

	habits, counts, err := listHabits(a.DB)

	if err != nil {

		a.Log.Error("list habits", "err", err)

	}

	habitRows := make([]habitRow, 0, len(habits))

	for _, h := range habits {

		habitRows = append(habitRows, habitToRow(h, counts[h.ID]))

	}

	records, err := listRecords(a.DB, 200)

	if err != nil {

		a.Log.Error("list records", "err", err)

	}

	web.Render(a.Templates, w, "index.html", dashboardData{

		Success: r.URL.Query().Get("success"),

		Error:   r.URL.Query().Get("error"),

		Habits:  habitRows,

		Days:    groupDashboard(records),

	}, a.Log)

}

// --- habits ---

func (a *App) newHabitHandler(w http.ResponseWriter, r *http.Request) {

	web.Render(a.Templates, w, "new.html", newHabitPageData{

		Error:      r.URL.Query().Get("error"),

		ValueTypes: valueTypes,

	}, a.Log)

}

func (a *App) settingsHandler(w http.ResponseWriter, r *http.Request) {

	habits, counts, err := listHabits(a.DB)

	if err != nil {

		a.Log.Error("list habits", "err", err)

	}

	habitRows := make([]habitRow, 0, len(habits))

	for _, h := range habits {

		habitRows = append(habitRows, habitToRow(h, counts[h.ID]))

	}

	web.Render(a.Templates, w, "settings.html", settingsPageData{

		Success:    r.URL.Query().Get("success"),

		Error:      r.URL.Query().Get("error"),

		ValueTypes: valueTypes,

		Habits:     habitRows,

	}, a.Log)

}

func (a *App) createHabitHandler(w http.ResponseWriter, r *http.Request) {

	if err := r.ParseForm(); err != nil {

		web.RedirectWithError(w, r, "/new", "Bad request")

		return

	}

	name := strings.TrimSpace(r.FormValue("name"))

	valueType := strings.TrimSpace(r.FormValue("value_type"))

	unit := strings.TrimSpace(r.FormValue("unit"))

	description := strings.TrimSpace(r.FormValue("description"))

	if name == "" {

		web.RedirectWithError(w, r, "/new", "Habit name is required")

		return

	}

	if !validValueType(valueType) {

		web.RedirectWithError(w, r, "/new", "Invalid value type")

		return

	}

	if _, err := insertHabit(a.DB, name, valueType, unit, description); err != nil {

		a.Log.Error("insert habit", "err", err)

		web.RedirectWithError(w, r, "/new", "Failed to create habit")

		return

	}

	web.RedirectWithSuccess(w, r, "/", "Habit created")

}

func (a *App) habitDetailHandler(w http.ResponseWriter, r *http.Request) {

	habit, err := getHabitByShortID(a.DB, r.PathValue("short_id"))

	if err != nil {

		a.Log.Error("get habit", "err", err)

		web.RedirectWithError(w, r, "/", "Failed to load habit")

		return

	}

	if habit == nil {

		http.NotFound(w, r)

		return

	}

	records, err := listRecordsForHabit(a.DB, habit.ID)

	if err != nil {

		a.Log.Error("list habit records", "err", err)

	}

	web.Render(a.Templates, w, "habit.html", habitPageData{

		Success: r.URL.Query().Get("success"),

		Error:   r.URL.Query().Get("error"),

		Habit:   habitToRow(*habit, len(records)),

		Days:    groupByDay(records),

	}, a.Log)

}

func (a *App) updateHabitHandler(w http.ResponseWriter, r *http.Request) {

	shortID := r.PathValue("short_id")

	target := "/settings"

	if err := r.ParseForm(); err != nil {

		web.RedirectWithError(w, r, target, "Bad request")

		return

	}

	name := strings.TrimSpace(r.FormValue("name"))

	valueType := strings.TrimSpace(r.FormValue("value_type"))

	if name == "" {

		web.RedirectWithError(w, r, target, "Habit name is required")

		return

	}

	if !validValueType(valueType) {

		web.RedirectWithError(w, r, target, "Invalid value type")

		return

	}

	if err := updateHabit(a.DB, shortID, name, valueType,

		strings.TrimSpace(r.FormValue("unit")), strings.TrimSpace(r.FormValue("description"))); err != nil {

		a.Log.Error("update habit", "err", err)

		web.RedirectWithError(w, r, target, "Failed to update habit")

		return

	}

	web.RedirectWithSuccess(w, r, target, "Habit updated")

}

func (a *App) deleteHabitHandler(w http.ResponseWriter, r *http.Request) {

	target := "/settings"

	if ref := r.FormValue("return_to"); ref != "" {

		target = ref

	}

	if err := deleteHabitByShortID(a.DB, r.PathValue("short_id")); err != nil {

		a.Log.Error("delete habit", "err", err)

		web.RedirectWithError(w, r, target, "Failed to delete habit")

		return

	}

	web.RedirectWithSuccess(w, r, target, "Habit deleted")

}

// --- records ---

func (a *App) createRecordHandler(w http.ResponseWriter, r *http.Request) {

	if err := r.ParseForm(); err != nil {

		web.RedirectWithError(w, r, "/", "Bad request")

		return

	}

	// Where to return to: the referring page (dashboard or habit detail).

	target := "/"

	if ref := r.FormValue("return_to"); ref != "" {

		target = ref

	}

	habit, err := getHabitByShortID(a.DB, strings.TrimSpace(r.FormValue("habit")))

	if err != nil {

		a.Log.Error("get habit for record", "err", err)

		web.RedirectWithError(w, r, target, "Failed to load habit")

		return

	}

	if habit == nil {

		web.RedirectWithError(w, r, target, "Select a habit")

		return

	}

	value, err := normalizeValue(habit.ValueType, r.FormValue("value"))

	if err != nil {

		web.RedirectWithError(w, r, target, err.Error())

		return

	}

	recordedAt, err := parseRecordedAt(r.FormValue("recorded_at"))

	if err != nil {

		web.RedirectWithError(w, r, target, "Invalid date/time")

		return

	}

	if _, err := insertRecord(a.DB, habit.ID, value, recordedAt); err != nil {

		a.Log.Error("insert record", "err", err)

		web.RedirectWithError(w, r, target, "Failed to add record")

		return

	}

	web.RedirectWithSuccess(w, r, target, "Record added")

}

func (a *App) updateRecordHandler(w http.ResponseWriter, r *http.Request) {

	shortID := r.PathValue("short_id")

	if err := r.ParseForm(); err != nil {

		web.RedirectWithError(w, r, "/", "Bad request")

		return

	}

	rec, err := getRecordByShortID(a.DB, shortID)

	if err != nil {

		a.Log.Error("get record", "err", err)

		web.RedirectWithError(w, r, "/", "Failed to load record")

		return

	}

	if rec == nil {

		http.NotFound(w, r)

		return

	}

	target := "/habits/" + rec.HabitShortID

	if ref := r.FormValue("return_to"); ref != "" {

		target = ref

	}

	value, err := normalizeValue(rec.ValueType, r.FormValue("value"))

	if err != nil {

		web.RedirectWithError(w, r, target, err.Error())

		return

	}

	recordedAt, err := parseRecordedAt(r.FormValue("recorded_at"))

	if err != nil {

		web.RedirectWithError(w, r, target, "Invalid date/time")

		return

	}

	if err := updateRecord(a.DB, shortID, value, recordedAt); err != nil {

		a.Log.Error("update record", "err", err)

		web.RedirectWithError(w, r, target, "Failed to update record")

		return

	}

	web.RedirectWithSuccess(w, r, target, "Record updated")

}

func (a *App) deleteRecordHandler(w http.ResponseWriter, r *http.Request) {

	target := "/"

	if ref := r.FormValue("return_to"); ref != "" {

		target = ref

	}

	if err := deleteRecordByShortID(a.DB, r.PathValue("short_id")); err != nil {

		a.Log.Error("delete record", "err", err)

		web.RedirectWithError(w, r, target, "Failed to delete record")

		return

	}

	web.RedirectWithSuccess(w, r, target, "Record deleted")

}

package main

import (

	"html/template"

	"log"

	"log/slog"

	"net/http"

	"os"

	"github.com/stevedylandev/andromeda/pkg/auth"

	"github.com/stevedylandev/andromeda/pkg/config"

	"github.com/stevedylandev/andromeda/pkg/sqlite"

)

func main() {

	config.LoadDotEnv(".env")

	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo}))

	dbPath := config.Getenv("HABBITS_DB_PATH", "habbits.sqlite")

	db, err := sqlite.Open(dbPath, habbitsSchema)

	if err != nil {

		log.Fatal(err)

	}

	defer db.Close()

	sessions := &auth.Store{DB: db, CookieName: "session", CookieSecure: config.GetenvBool("COOKIE_SECURE", false)}

	if err := sessions.EnsureSchema(); err != nil {

		log.Fatal(err)

	}

	sessions.PruneExpired()

	adminPassword := config.Getenv("HABBITS_PASSWORD", "")

	if adminPassword == "" {

		logger.Warn("HABBITS_PASSWORD not set; admin login is disabled")

	}

	tmpl := template.Must(template.ParseFS(appFS, "templates/*.html"))

	app := &App{

		DB:            db,

		Log:           logger,

		Templates:     tmpl,

		Sessions:      sessions,

		AdminPassword: adminPassword,

		APIKey:        config.Getenv("HABBITS_API_KEY", ""),

		CookieSecure:  sessions.CookieSecure,

		BaseURL:       config.Getenv("BASE_URL", "http://localhost:3000"),

	}

	addr := config.Getenv("HOST", "0.0.0.0") + ":" + config.Getenv("PORT", "3000")

	logger.Info("habbits server running", "addr", addr)

	if err := http.ListenAndServe(addr, app.routes()); err != nil {

		log.Fatal(err)

	}

}

package main

import (

	"net/http"

	"github.com/stevedylandev/andromeda/pkg/auth"

	"github.com/stevedylandev/andromeda/pkg/darkmatter"

	"github.com/stevedylandev/andromeda/pkg/web"

)

func (a *App) routes() *http.ServeMux {

	mux := http.NewServeMux()

	requireSession := func(next http.HandlerFunc) http.HandlerFunc {

		return a.Sessions.RequireSession("/login", next)

	}

	requireAPIKey := func(next http.HandlerFunc) http.HandlerFunc {

		return auth.RequireAPIKey(a.APIKey, next)

	}

	// Public: only the login flow and static assets.

	mux.HandleFunc("GET /login", a.loginGetHandler)

	mux.HandleFunc("POST /login", a.loginPostHandler)

	mux.HandleFunc("GET /logout", a.logoutHandler)

	mux.HandleFunc("GET /static/", web.EmbeddedHandler(appFS, "static"))

	darkmatter.Mount(mux, "/assets")

	// Everything else requires a session (fully gated admin app).

	mux.HandleFunc("GET /", requireSession(a.dashboardHandler))

	mux.HandleFunc("GET /new", requireSession(a.newHabitHandler))

	mux.HandleFunc("GET /settings", requireSession(a.settingsHandler))

	mux.HandleFunc("GET /export.csv", requireSession(a.exportHandler))

	mux.HandleFunc("POST /habits", requireSession(a.createHabitHandler))

	mux.HandleFunc("GET /habits/{short_id}", requireSession(a.habitDetailHandler))

	mux.HandleFunc("POST /habits/{short_id}", requireSession(a.updateHabitHandler))

	mux.HandleFunc("POST /habits/{short_id}/delete", requireSession(a.deleteHabitHandler))

	mux.HandleFunc("POST /records", requireSession(a.createRecordHandler))

	mux.HandleFunc("POST /records/{short_id}", requireSession(a.updateRecordHandler))

	mux.HandleFunc("POST /records/{short_id}/delete", requireSession(a.deleteRecordHandler))

	// Read-only JSON API, gated by X-API-Key (disabled when key is empty).

	mux.HandleFunc("GET /api/habits", requireAPIKey(a.apiListHabits))

	mux.HandleFunc("GET /api/records", requireAPIKey(a.apiListRecords))

	return mux

}

/* App-local styles for habbits. The shared design system (palette, typography,

   forms, admin lists) comes from /assets/darkmatter.css. Only small layout

   extensions live here. */

.section {

  width: 100%;

  margin-bottom: 1.5rem;

}

.section h2 {

  font-size: 16px;

  margin: 0 0 0.5rem;

}

/* Inline record edit row: value + datetime + save on one line, aligned. */

.record-edit {

  align-items: flex-end;

  flex: 1;

  gap: 0.5rem;

}

.record-edit .form-field {

  margin: 0;

}

/* Each habit's edit form on the settings page, divided by a hairline. */

.settings-habit {

  padding: 1rem 0;

  border-bottom: 1px solid #333;

}

.settings-habit .inline-form {

  margin-top: 0.5rem;

}

/* Day / habit groupings in record lists. */

.day-group {

  margin-bottom: 1rem;

}