tracker

type AgentPR ¶

type AgentPR struct {
	Identifier string // "KEY-N" — the human handle
	ProjectKey string // the tracker project KEY the row lives under
	Number     int    // per-project monotonic number
}

AgentPR is the created row's stable handle: KEY-N plus the parts to build it.

func CreateAgentPR(ctx context.Context, in AgentPRInput) (AgentPR, error)

type AgentPRInput ¶

type AgentPRInput struct {
	Org      string // tenant (isolation key)
	Project  string // IAM project slug (physical DB scope); "" = the org default
	Repo     string // git repo the branch was pushed to (the Repo binding)
	Base     string // base branch the PR targets (recorded in the body)
	Head     string // the pushed branch (the ExtRef anchor)
	Title    string // work-item title (from the task)
	Body     string // description: summary / diffstat + session link
	Assignee string // the agent ref (e.g. "hanzo")
}

AgentPRInput is the closed set a coding run supplies to open its PR row. The four discriminators are set here: Kind is always "pr", Source always "agent", Repo binds the git repo, and Head (the pushed branch) is the ExtRef anchor.

type Issue ¶

type Issue struct {
	ID          string
	ProjectID   string
	Org         string
	Number      int
	Kind        string // issue | pr | epic (default "issue")
	Source      string // team | git | crm | helpdesk | cms | agent (default "team")
	Repo        string // git repo binding; "" = not repo-bound
	ExtRef      string // external anchor (PR branch, or link into another plane)
	Title       string
	Description string
	Status      string
	Priority    string
	Assignee    string
	Labels      string
	CreatedAt   int64
	UpdatedAt   int64
}

Issue is THE ONE engineering/project work-item primitive for Hanzo — polymorphic by Kind so a git issue, a pull request and a parent epic are all the same row, and every work-item surface (hanzo.team's board, a git repo's Issues/PRs tab, an agent's queue) is a FILTER over this table, never a second tracker. It is NOT the domain-record plane: helpdesk tickets, CMS content and CRM deals live on framework.DocType / crm and link here by ExtRef — see contract.go for the three-plane boundary. Number is monotonic PER PROJECT (KEY-1, KEY-2, …), allocated under the single-writer transaction in CreateIssue so it never races. Status is the board column; Labels is a comma-joined tag string (split at the HTTP boundary).

The four discriminators (Kind, Source, Repo, ExtRef) are the alignment spine:

• Kind: issue | pr | epic — what it IS (the small closed work-item set).
• Source: team | git | crm | helpdesk | cms | agent — which surface OPENED it.
• Repo: the git repo it belongs to (Kind pr/issue from git); "" otherwise — so a repo's Issues/PRs tab is `ListIssues(... Filter{Repo, Kind})`.
• ExtRef: the external anchor (PR branch, or a link INTO another plane).

They are identity, set once at Create and immutable thereafter (Update touches only the mutable board state), so a row never migrates between surfaces.

type IssueFilter ¶

type IssueFilter struct {
	Status string
	Kind   string
	Repo   string
	Source string
}

IssueFilter narrows ListIssues. All fields optional (empty = no constraint). This is the ONE knob every work-item surface turns: hanzo.team passes {Status}, a git repo's Issues tab passes {Repo, Kind:"issue"}, its PRs tab {Repo, Kind:"pr"}, an agent's queue {Source:"agent"}.

type Project ¶

type Project struct {
	ID          string
	Org         string
	Key         string
	Name        string
	Description string
	CreatedAt   int64
	UpdatedAt   int64
}

Project is an org-scoped issue tracker project (a Linear "team"). Its Key is the org-unique, uppercase handle that both routes the URL (/v1/tracker/ projects/:key) AND prefixes every issue identifier (KEY-<number>). Org isolation is the org column, filtered on every query.

Distinct from projects.Project (not a duplicate): that is the Slug-keyed deployable site forming this tracker's physical tenant boundary; these KEY-prefixed teams are rows WITHIN it.

type Store ¶

type Store struct {
	// contains filtered or unexported fields
}

Store is one (org, project)'s tracker database — ONE SQLite file per project at {DataDir}/orgs/{orgSlug}/projects/{projectSlug}/tracker.db (opened via cloud.OrgDB). tracker is project-scoped: the physical boundary is the IAM project, with the org column retained as defense-in-depth. MaxOpenConns(1) serializes writes against the file lock (and makes the CreateIssue number allocation a safe read-modify-write inside one transaction).

func (s *Store) Close() error

func (s *Store) CreateIssue(ctx context.Context, i Issue) (Issue, error)

func (s *Store) CreateProject(ctx context.Context, p Project) error

func (s *Store) DeleteIssue(ctx context.Context, org, projectID string, number int) (bool, error)

func (s *Store) DeleteProject(ctx context.Context, org, key string) (bool, error)

func (s *Store) GetIssue(ctx context.Context, org, projectID string, number int) (Issue, error)

func (s *Store) GetIssueByExtRef(ctx context.Context, org, projectID, extRef string) (Issue, error)

func (s *Store) GetProject(ctx context.Context, org, key string) (Project, error)

func (s *Store) ListIssues(ctx context.Context, org, projectID string, f IssueFilter) ([]Issue, error)

func (s *Store) ListProjects(ctx context.Context, org string) ([]Project, error)

func (s *Store) UpdateIssue(ctx context.Context, i Issue) error

func (s *Store) UpdateProject(ctx context.Context, p Project) error