action palette phase 3-4

This commit is contained in:
booleanmaybe 2026-04-18 23:24:21 -04:00
parent db019108be
commit 1596bc9c39
12 changed files with 25 additions and 579 deletions

View file

@ -209,12 +209,6 @@ views:
filter: select where type = "epic" and status = "backlog" and priority > 1 order by priority, points desc
action: update where id = id() set status="backlog" priority=2
view: expanded
- name: Help
description: "Keyboard shortcuts, navigation, and usage guide"
type: doki
fetcher: internal
text: "Help"
key: "?"
- name: Docs
description: "Project notes and documentation files"
type: doki

View file

@ -233,8 +233,19 @@ actions:
Each action has:
- `key` - a single printable character used as the keyboard shortcut
- `label` - description shown in the header
- `label` - description shown in the header and action palette
- `action` - a `ruki` statement (`update`, `create`, `delete`, or `select`)
- `hot` - (optional) controls header visibility. `hot: true` shows the action in the header, `hot: false` hides it. When absent, actions default to visible in the header. This does not affect the action palette — all actions are always discoverable via `?` regardless of the `hot` setting
Example — keeping a verbose action out of the header but still accessible from the palette:
```yaml
actions:
- key: "x"
label: "Archive and notify"
action: update where id = id() set status="done"
hot: false
```
When the shortcut key is pressed, the action is applied to the currently selected tiki.
For example, pressing `b` in the Backlog plugin changes the selected tiki's status to `ready`, effectively moving it to the board.

View file

@ -16,7 +16,7 @@ cd /tmp && tiki demo
```
Move your tiki around the board with `Shift ←/Shift →`.
Make sure to press `?` for help.
Press `?` to open the Action Palette — it lists all available actions with their shortcuts.
Press `F1` to open a sample doc root. Follow links with `Tab/Enter`
## AI skills
@ -56,7 +56,7 @@ Store your notes in remotes!
`tiki` TUI tool allows creating, viewing, editing and deleting tikis as well as creating custom plugins to
view any selection, for example, Recent tikis, Architecture docs, Saved prompts, Security review, Future Roadmap
Read more by pressing `?` for help
Press `?` to open the Action Palette and discover all available actions
# AI skills

View file

@ -92,7 +92,7 @@ this will clone and show a demo project. Once done you can try your own:
`cd` into your **git** repo and run `tiki init` to initialize.
Move your tiki around the board with `Shift ←/Shift →`.
Make sure to press `?` for help.
Press `?` to open the Action Palette — it lists all available actions with their shortcuts.
Press `F1` to open a sample doc root. Follow links with `Tab/Enter`
### AI skills
@ -142,7 +142,7 @@ Store your notes in remotes!
`tiki` TUI tool allows creating, viewing, editing and deleting tikis as well as creating custom plugins to
view any selection, for example, Recent tikis, Architecture docs, Saved prompts, Security review, Future Roadmap
Read more by pressing `?` for help
Press `?` to open the Action Palette and discover all available actions
## AI skills

View file

@ -4,7 +4,7 @@ import "path"
// AITool defines a supported AI coding assistant.
// To add a new tool, add an entry to the aiTools slice below.
// NOTE: also update view/help/tiki.md which lists tool names in prose.
// NOTE: the action palette (press ?) surfaces available actions; update docs if tool names change.
type AITool struct {
Key string // config identifier: "claude", "gemini", "codex", "opencode"
DisplayName string // human-readable label for UI: "Claude Code"

View file

@ -104,12 +104,6 @@ views:
filter: select where type = "epic" and status = "backlog" and priority > 1 order by priority, points desc
action: update where id = id() set status="backlog" priority=2
view: expanded
- name: Help
description: "Keyboard shortcuts, navigation, and usage guide"
type: doki
fetcher: internal
text: "Help"
key: "?"
- name: Docs
description: "Project notes and documentation files"
type: doki

View file

@ -1,7 +1,6 @@
package view
import (
_ "embed"
"fmt"
"log/slog"
@ -18,15 +17,6 @@ import (
"github.com/rivo/tview"
)
//go:embed help/help.md
var helpMd string
//go:embed help/tiki.md
var tikiMd string
//go:embed help/custom.md
var customMd string
// DokiView renders a documentation plugin (navigable markdown)
type DokiView struct {
root *tview.Flex
@ -94,13 +84,15 @@ func (dv *DokiView) build() {
MermaidOptions: dv.mermaidOpts,
})
// fetcher: internal is intentionally preserved as a supported pattern for
// code-only internal docs, even though no default workflow currently uses it.
//
// The default Help plugin previously used this with embedded markdown:
// cnt := map[string]string{"Help": helpMd, "tiki.md": tikiMd, "view.md": customMd}
// provider := &internalDokiProvider{content: cnt}
// That usage was replaced by the action palette (press ? to open).
case "internal":
cnt := map[string]string{
"Help": helpMd,
"tiki.md": tikiMd,
"view.md": customMd,
}
provider := &internalDokiProvider{content: cnt}
provider := &internalDokiProvider{content: map[string]string{}}
content, err = provider.FetchContent(nav.NavElement{Text: dv.pluginDef.Text})
dv.md = markdown.NewNavigableMarkdown(markdown.NavigableMarkdownConfig{

View file

@ -1,249 +0,0 @@
# Customization
First of all, you just navigated to a linked file. To go back press `Left` arrow or `Alt-Left`
To go forward press `Right` arrow or `Alt-Right`
tiki is highly customizable. `workflow.yaml` lets you define your workflow statuses and configure views (plugins) for how tikis are displayed and organized. Statuses define the lifecycle stages your tasks move through, while plugins control what you see and how you interact with your work. This section covers both.
## Statuses
Workflow statuses are defined in `workflow.yaml` under the `statuses:` key. Every tiki project must define its statuses here — there is no hardcoded fallback. The default `workflow.yaml` ships with:
```yaml
statuses:
- key: backlog
label: Backlog
emoji: "📥"
default: true
- key: ready
label: Ready
emoji: "📋"
active: true
- key: in_progress
label: "In Progress"
emoji: "⚙️"
active: true
- key: review
label: Review
emoji: "👀"
active: true
- key: done
label: Done
emoji: "✅"
done: true
```
Each status has:
- `key` — canonical identifier (lowercase, underscores). Used in filters, actions, and frontmatter.
- `label` — display name shown in the UI
- `emoji` — emoji shown alongside the label
- `active` — marks the status as "active work" (used for burndown charts and activity tracking)
- `default` — the status assigned to new tikis (exactly one status should have this)
- `done` — marks the status as "completed" (used for completion tracking)
You can customize these to match your team's workflow. All filters and actions in view definitions must reference valid status keys.
## Plugins
tiki TUI app is much like a lego - everything is a customizable view. Here is, for example,
how Backlog is defined:
```yaml
views:
plugins:
- name: Backlog
key: "F3"
lanes:
- name: Backlog
columns: 4
filter: select where status = "backlog" and type != "epic" order by priority, id
actions:
- key: "b"
label: "Add to board"
action: update where id = id() set status="ready"
```
that translates to - show all tikis in the status `backlog`, sort by priority and then by ID arranged visually in 4 columns in a single lane.
The `actions` section defines a keyboard shortcut `b` that moves the selected tiki to the board by setting its status to `ready`
You define the name, description, hotkey, and `ruki` expressions for filtering and actions. Save this into a `workflow.yaml` file in the config directory
Likewise the documentation is just a plugin:
```yaml
views:
plugins:
- name: Docs
type: doki
fetcher: file
url: "index.md"
key: "F2"
```
that translates to - show `index.md` file located under `.doc/doki`
installed in the same way
### Multi-lane plugin
Backlog is a pretty simple plugin in that it displays all tikis in a single lane. Multi-lane tiki plugins offer functionality
similar to that of the board. You can define multiple lanes per view and move tikis around with Shift-Left/Shift-Right
much like in the board. You can create a multi-lane plugin by defining multiple lanes in its definition and assigning
actions to each lane. An action defines what happens when you move a tiki into the lane. Here is a multi-lane plugin
definition that roughly mimics the board:
```yaml
name: Custom
key: "F4"
lanes:
- name: Ready
columns: 1
width: 20
filter: select where status = "ready" order by priority, title
action: update where id = id() set status="ready"
- name: In Progress
columns: 1
width: 30
filter: select where status = "inProgress" order by priority, title
action: update where id = id() set status="inProgress"
- name: Review
columns: 1
width: 30
filter: select where status = "review" order by priority, title
action: update where id = id() set status="review"
- name: Done
columns: 1
width: 20
filter: select where status = "done" order by priority, title
action: update where id = id() set status="done"
```
### Lane width
Each lane can optionally specify a `width` as a percentage (1-100) to control how much horizontal space it occupies. Widths are relative proportions — they don't need to sum to 100. If width is omitted, the lane gets an equal share of the remaining space.
```yaml
lanes:
- name: Sidebar
width: 25
- name: Main
width: 50
- name: Details
width: 25
```
If no lanes specify width, all lanes are equally sized (the default behavior).
### Global plugin actions
You can define actions under `views.actions` that are available in **all** tiki plugin views:
```yaml
views:
actions:
- key: "a"
label: "Assign to me"
action: update where id = id() set assignee=user()
plugins:
- name: Kanban
...
```
Global actions appear in the header alongside per-plugin actions. If a per-plugin action uses the same key, the per-plugin action takes precedence for that view. When multiple workflow files define `views.actions`, they merge by key — later files override same-keyed globals from earlier files.
### Per-plugin actions
In addition to lane actions that trigger when moving tikis between lanes, you can define plugin-level actions
that apply to the currently selected tiki via a keyboard shortcut. These shortcuts are displayed in the header when the plugin is active.
```yaml
actions:
- key: "b"
label: "Add to board"
action: update where id = id() set status="ready"
- key: "a"
label: "Assign to me"
action: update where id = id() set assignee=user()
```
Each action has:
- `key` - a single printable character used as the keyboard shortcut
- `label` - description shown in the header
- `action` - a `ruki` statement (`update`, `create`, `delete`, or `select`)
When the shortcut key is pressed, the action is applied to the currently selected tiki.
For example, pressing `b` in the Backlog plugin changes the selected tiki's status to `ready`, effectively moving it to the board.
`select` actions execute for side-effects only — the output is ignored. They don't require a selected tiki.
### ruki expressions
Plugin filters, lane actions, and plugin actions all use the `ruki` language. Filters use `select` statements. Actions support `update`, `create`, `delete`, and `select` statements (`select` for side-effects only, output ignored).
#### Filter (select)
The `filter` field uses a `ruki` `select` statement to determine which tikis appear in a lane. Sorting is part of the select — use `order by` to control display order.
```sql
-- basic filter with sort
select where status = "backlog" and type != "epic" order by priority, id
-- recent items, most recent first
select where now() - updatedAt < 24hour order by updatedAt desc
-- multiple conditions
select where type = "epic" and status = "backlog" and priority > 1 order by priority, points desc
-- assigned to me
select where assignee = user() order by priority
```
#### Action (update)
The `action` field uses a `ruki` `update` statement. In plugin context, `id()` refers to the currently selected tiki.
```sql
-- set status on move
update where id = id() set status="ready"
-- set multiple fields
update where id = id() set status="backlog" priority=2
-- assign to current user
update where id = id() set assignee=user()
```
#### Supported fields
- `id` - task identifier (e.g., "TIKI-M7N2XK")
- `title` - task title text
- `type` - task type (must match a key defined in `workflow.yaml` types)
- `status` - workflow status (must match a key defined in `workflow.yaml` statuses)
- `assignee` - assigned user
- `priority` - numeric priority value (1-5)
- `points` - story points estimate
- `tags` - list of tags
- `dependsOn` - list of dependency tiki IDs
- `due` - due date (YYYY-MM-DD format)
- `recurrence` - recurrence pattern (cron format)
- `createdAt` - creation timestamp
- `updatedAt` - last update timestamp
#### Conditions
- **Comparison**: `=`, `!=`, `>`, `>=`, `<`, `<=`
- **Logical**: `and`, `or`, `not` (precedence: not > and > or)
- **Membership**: `"value" in field`, `status not in ["done", "cancelled"]`
- **Emptiness**: `assignee is empty`, `tags is not empty`
- **Quantifiers**: `dependsOn any status != "done"`, `dependsOn all status = "done"`
- **Grouping**: parentheses `()` to control evaluation order
#### Literals and built-ins
- Strings: double-quoted (`"ready"`, `"alex"`)
- Integers: `1`, `5`
- Dates: `2026-03-25`
- Durations: `2hour`, `14day`, `3week`, `1month`
- Lists: `["bug", "frontend"]`
- `user()` — current git user
- `now()` — current timestamp
- `id()` — currently selected tiki (in plugin context)
- `count(select where ...)` — count matching tikis

View file

@ -1,54 +0,0 @@
# About
tiki is a lightweight issue-tracking, project management and knowledge base tool that uses git repo
to store issues, stories and documentation.
- tiki uses Markdown files stored in `tiki` format under `.doc/tiki` subdirectory of a git repo
to track issues, stories or epics. Press `Tab` then `Enter` to select this link: [tiki](tiki.md) and read about `tiki` format
- Project-related documentation is stored under `.doc/doki` also in Markdown format. They can be linked/back-linked
for easier navigation.
>Since they are stored in git they are automatically versioned and can be perfectly synced to the current
state of the repo or its git branch. Also, all past versions and deleted items remain in git history of the repo
## Board
Board is a simple Kanban-style board where tikis can be moved around with `Shift-Right` and `Shift-Left`
As tikis are moved their status changes correspondingly. Statuses are configurable via `workflow.yaml`.
Tikis can be opened for viewing or editing or searched by ID, title, description and tags.
To quickly capture an idea - hit `n` in the board or any tiki view, type in the title and press Enter
You can also edit its status, type and other fields, or open the source file directly for editing in your favorite editor
## Documentation
Documentation is a Wiki-style knowledge base stored alongside the project files
Documentation and various other files such as prompts can also be stored under git version control
The documentation can be organized using Markdown links and navigated in the `tiki` cli using Tab/Shift-Tab and Enter
## AI
Since Markdown is an AI-native format issues and documentation can easily be created and maintained using AI tools.
tiki can optionally install skills to enable AI tools such as `claude`, `gemini`, `codex` or `opencode` to understand its
format. Try:
>create a tiki from @my-markdown.md with title "Fix UI bug"
or:
>mark tiki ABC123 as complete
## Customization
Press `Tab` then `Enter` to read [customize](view.md) to understand how to customize or extend tiki with your own plugins
## Configuration
tiki can be configured via `config.yaml` file stored in the same directory where executable is installed
## Header
- Context help showing keyboard shortcuts for the current view
- Various statistics - tiki count, git branch and current user name
- Burndown chart - number of incomplete tikis remaining

View file

@ -1,230 +0,0 @@
# tiki format
First of all, you just navigated to a linked file. To go back press `Left` arrow or `Alt-Left`
To go forward press `Right` arrow or `Alt-Right`
Keep your tickets in your pockets!
`tiki` refers to a task or a ticket (hence tiki) stored in your **git** repo
- like a ticket it can have a status, priority, assignee, points, type and multiple tags attached to it
- they are essentially just Markdown files and you can use full Markdown syntax to describe a story or a bug
- they are stored in `.doc/tiki` subdirectory and are **git**-controlled - they are added to **git** when they are created,
removed when they are done and the entire history is preserved in **git** repo
- because they are in **git** they can be perfectly synced up to the state of your repo or a branch
- you can use either the `tiki` CLI tool or any of the AI coding assistant to work with your tikis
## tiki format
Tiki stores tickets (aka tikis) and documents (aka dokis) in the git repo along with code
They are stored under `.doc` directory and are supposed to be checked-in/versioned along with all other files
The `.doc/` directory contains two main subdirectories:
- **doki/**: Documentation files (wiki-style markdown pages)
- **tiki/**: Task files (kanban style tasks with YAML frontmatter)
## Directory Structure
```
.doc/
├── doki/
│ ├── index.md
│ ├── page2.md
│ ├── page3.md
│ └── sub/
│ └── page4.md
└── tiki/
├── tiki-k3x9m2.md
├── tiki-7wq4na.md
├── tiki-p8j1fz.md
└── ...
```
## Tiki files
Tiki files are saved in `.doc/tiki` directory and can be managed via:
- `tiki` cli
- AI tools such as `claude`, `gemini`, `codex` or `opencode`
- manually
A tiki is made of its frontmatter that includes all fields related to a tiki status and types and its description
in Markdown format
```text
---
title: Sample title
type: story
status: backlog
assignee: booleanmaybe
priority: 3
points: 10
tags:
- UX
- test
dependsOn:
- TIKI-ABC123
- TIKI-DEF456
due: 2026-04-01
recurrence: 0 0 * * MON
---
This is the description of a tiki in Markdown:
# Tests
Make sure all tests pass
## Integration tests
Integration test cases
```
### Fields
#### title
**Required.** String. The name of the tiki. Must be non-empty, max 200 characters.
```yaml
title: Implement user authentication
```
#### type
Optional string. Defaults to the first type defined in `workflow.yaml`.
Valid values are the type keys defined in the `types:` section of `workflow.yaml`.
Default types: `story`, `bug`, `spike`, `epic`. Each type can have a label and emoji
configured in `workflow.yaml`. Aliases are not supported; use the canonical key.
```yaml
type: bug
```
#### status
Optional string. Must match a status defined in your project's `workflow.yaml`.
Default: the status marked `default: true` in the workflow (typically `backlog`).
If the value doesn't match any status in the workflow, it falls back to the default.
```yaml
status: in_progress
```
#### priority
Optional. Stored in the file as an integer 15 (1 = highest, 5 = lowest). Default: `3`.
In the TUI, priority is displayed as text with a color indicator:
| Value | TUI label | Emoji |
|-------|-----------|-------|
| 1 | High | 🔴 |
| 2 | Medium High | 🟠 |
| 3 | Medium | 🟡 |
| 4 | Medium Low | 🔵 |
| 5 | Low | 🟢 |
Text aliases are accepted when creating tikis (case-insensitive, hyphens/underscores/spaces as separators):
`high` = 1, `medium-high` = 2, `medium` = 3, `medium-low` = 4, `low` = 5.
```yaml
priority: 2
```
#### points
Optional integer. Range: `0` to `maxPoints` (configurable via `tiki.maxPoints`, default max is 10).
`0` means unestimated. Values outside the valid range default to `maxPoints / 2` (typically 5).
```yaml
points: 3
```
#### assignee
Optional string. Free-form text, typically a username. Default: empty.
```yaml
assignee: booleanmaybe
```
#### tags
Optional string list. Arbitrary labels attached to a tiki. Empty and whitespace-only strings are filtered out.
Default: empty. Both YAML list formats are accepted:
```yaml
# block list
tags:
- frontend
- urgent
# inline list
tags: [frontend, urgent]
```
#### dependsOn
Optional string list. Each entry must be a valid tiki ID in `TIKI-XXXXXX` format (6-character alphanumeric suffix)
referencing an existing tiki. IDs are automatically uppercased. A dependency means this tiki is blocked by the listed tikis.
Default: empty. Both YAML list formats are accepted:
```yaml
# block list
dependsOn:
- TIKI-ABC123
- TIKI-DEF456
# inline list
dependsOn: [TIKI-ABC123, TIKI-DEF456]
```
#### due
Optional date in `YYYY-MM-DD` format (date-only, no time component).
Represents when the task should be completed by. Empty string or omitted field means no due date.
```yaml
due: 2026-04-01
```
#### recurrence
Optional cron string specifying a recurrence pattern. Displayed as English in the TUI.
This is metadata-only — it does not auto-create tasks on completion.
Supported patterns:
| Cron | Display |
|------|---------|
| (empty) | None |
| `0 0 * * *` | Daily |
| `0 0 * * MON` | Weekly on Monday |
| `0 0 * * TUE` | Weekly on Tuesday |
| `0 0 * * WED` | Weekly on Wednesday |
| `0 0 * * THU` | Weekly on Thursday |
| `0 0 * * FRI` | Weekly on Friday |
| `0 0 * * SAT` | Weekly on Saturday |
| `0 0 * * SUN` | Weekly on Sunday |
| `0 0 1 * *` | Monthly |
```yaml
recurrence: 0 0 * * MON
```
### Derived fields
Fields such as:
- `created by`
- `created at`
- `updated at`
are not stored and are calculated from git - the time and git user who created a tiki or the time it was last modified
## Doki files
Documents are any file in a Markdown format saved under `.doc/doki` directory. They can be organized in subdirectory
tree and include links between them or to external Markdown files

View file

@ -163,12 +163,6 @@ views:
- key: "D"
label: "Bump one week"
action: update where id = id() set dueBy=now() + 7day
- name: Help
description: "Keyboard shortcuts, navigation, and usage guide"
type: doki
fetcher: internal
text: "Help"
key: "?"
- name: Docs
description: "Project notes and documentation files"
type: doki

View file

@ -105,12 +105,6 @@ views:
filter: select where type = "epic" and status = "backlog" and priority > 1 order by priority, points desc
action: update where id = id() set status="backlog" priority=2
view: expanded
- name: Help
description: "Keyboard shortcuts, navigation, and usage guide"
type: doki
fetcher: internal
text: "Help"
key: "?"
- name: Docs
description: "Project notes and documentation files"
type: doki