mktask 0.1.0__tar.gz

mktask-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.pyc
+*.db
+*.db-shm
+*.db-wal
+*.egg-info/
+dist/
+build/
+.pytest_cache/

mktask-0.1.0/CLAUDE.md

@@ -0,0 +1,63 @@
+# mktask
+
+Work task prioritizer built on [mkio](https://github.com/markuskimius/mkio) (config-driven microservice backend: SQLite + WebSocket services) and [mkui](https://github.com/markuskimius/mkui) (config-driven Web Components workspace). Sibling of [mkfix](../mkfix), whose structure this repo copies.
+
+## Quick start
+
+```bash
+pip install -e '.[test]'
+mktask                    # http://127.0.0.1:8080/, mktask.db in cwd
+mktask -d :memory: -p 9090
+python -m pytest
+```
+
+## Project layout
+
+```
+mktask/
+  __init__.py       __version__ (single source of truth) + lazy serve()
+  __main__.py       CLI (argparse) → mkio create_app(); resolves "__mkui__" static route
+  mktask.toml       tables, services, static routes (no version key — injected at load)
+  static/
+    index.html      imports /mkui/src/index.js, fetches app.json, sets mkio.url from location
+    app.json        the whole UI: menubar, statusbar, panes, frames, dialogs, layouts
+    mktask.css      app overrides on top of mkui.css
+tests/
+  test_cli.py       --help / --version / bad config path (subprocess)
+  test_config.py    _load_config, _find_config, main() parsing, serve() overrides, _check_port, banner
+  test_server.py    boots the real server on a free port (-d :memory:): HTTP routes, every task op,
+                    server-side query filter, saved-layouts round trip, --host, busy-port exit
+  test_ui_config.py static integrity of app.json against mktask.toml and index.html
+PLAN.md             the original skeleton plan; phases and deferred work
+```
+
+## Architecture
+
+- `serve()` in `__main__.py` loads `mktask.toml` via `mkio.config.load_config`, injects `version = __version__`, resolves `"__mkui__"` to `mkui.static_dir` and relative static dirs against the TOML's directory, probes the port (`_check_port`), then `create_app(cfg).run()`. A startup hook prints the banner.
+- `_check_port` runs before `create_app`: a bind failure inside `app.start()` happens after the startup hooks have opened the database, whose aiosqlite threads then keep the process alive after the traceback. The probe turns that hang into an exit-1 with a one-line error (`test_port_in_use_fails_cleanly`).
+- `_find_config()` prefers `./mktask.toml` over the packaged one, so a user can copy the TOML out and customize it.
+- The UI is JSON, not TOML: `index.html` fetches `/static/app.json` with `cache: "no-cache"` (mkio serves statics without Cache-Control) and calls `setConfig`. No `[config]` route in the TOML.
+- `mkio.expect` in app.json pins `name` and `expr` only. Never pin `version` — every release would then show "Server mismatch" (`test_ui_config.py` guards this).
+
+## Data model
+
+One table, `tasks`: `title`, `notes`, `status` (`open` | `done`), `importance` and `urgency` (1..5), `due` (ISO date or `''`), `created_at` / `updated_at` / `done_at` (UTC `YYYY-MM-DD HH:MM:SS`, matching SQLite's `CURRENT_TIMESTAMP`). Timestamps on update come from the client: buttons and the Edit dialog send `${TIME(NOW(), '%Y-%m-%d %H:%M:%S')}` (mkio expression stdlib, UTC by default) because mkio transaction `defaults` are static values.
+
+The `score` column is virtual: `values.score = "importance * urgency"` on the `tasks` pane. It is the placeholder for the real prioritization model (see PLAN.md, Deferred).
+
+## Services (`mktask.toml`)
+
+- `tasks` — transaction; ops `add` (defaults for notes/importance/urgency/due), `edit`, `done` (defaults `status = "done"`), `reopen` (defaults `status = "open"`, `done_at = ""`), `delete`. Fields listed without a `defaults` entry are required by mkio.
+- `all_tasks` — query on `tasks`, `filterable = ["status"]`. The blotter subscribes to this.
+- `mkui_layouts`, `mkui_layouts_list`, `mkui_layouts_get` — verbatim from mkui's scaffold; mktask has no login so every save lands under owner `''`.
+
+## UI (`app.json`)
+
+- `tasks` pane: `mkio-table` with default filter `status = ["open"]`, `sort = "-score"`, `select.state = "selected_task"`. Buttons: `+ Add` (dialog → `tasks.add`), `Edit` (`unit = "row"`, dialog prefilled from `${row.*}` with hidden `id` and `updated_at`), `Done` / `Reopen` (transaction buttons gated by `enable.when` on `status`), `Delete` (a dialog with a readonly title line acts as the confirmation — mkui has no confirm on transaction buttons).
+- `task-detail` pane: two `text` widgets over `state.selected_task`. Text widget templates see `state.<path>` (not bare names) and the expression language has no ternary — use `IF(...)`.
+- Menubar `Tasks` has `table.filter` entries: `{"status": ["open"]}` with `merge` shows open only; `{"status": null}` with `merge` clears that column's filter.
+- `test_ui_config.py` checks every dialog/button field against the op's `fields` + `key` (and that every field without a `defaults` entry is sent); it also checks that `${row.x}`, `values`, `styles`, `sort`, `filters`, and text-widget `state.x` references name real columns and declared state. Add the column to `mktask.toml` before using it in the UI.
+
+## Versioning and release
+
+`mktask/__init__.py` `__version__` is the single source of truth (hatch dynamic version). Release (`/cut`): bump it, update README/CLAUDE/tests, commit as `Release vX.Y.Z: summary`, push, `rm -f dist/*; python -m build`, `twine upload dist/*`, then `pip install --upgrade mktask` so the user's venv runs the published wheel (siblings mkfix/mkui are installed non-editable there; mkio is editable). No git tags, matching mkfix.

mktask-0.1.0/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding any notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Mark Kim
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

mktask-0.1.0/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.5
+Name: mktask
+Version: 0.1.0
+Summary: Work task prioritizer built on mkio and mkui
+Project-URL: Homepage, https://github.com/markuskimius/mktask
+Project-URL: Repository, https://github.com/markuskimius/mktask
+Project-URL: Issues, https://github.com/markuskimius/mktask/issues
+Author: Mark Kim
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: mkio,mkui,prioritization,tasks,todo
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Scheduling
+Requires-Python: >=3.11
+Requires-Dist: mkio>=0.2.0
+Requires-Dist: mkui>=0.2.9
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-aiohttp; extra == 'test'
+Requires-Dist: pytest-asyncio; extra == 'test'
+Description-Content-Type: text/markdown
+
+# mktask
+
+[![PyPI](https://img.shields.io/pypi/v/mktask)](https://pypi.org/project/mktask/)
+[![Python](https://img.shields.io/pypi/pyversions/mktask)](https://pypi.org/project/mktask/)
+[![License](https://img.shields.io/pypi/l/mktask)](https://github.com/markuskimius/mktask/blob/main/LICENSE)
+
+A work task prioritizer built on [mkio](https://github.com/markuskimius/mkio)
+(config-driven microservice backend) and
+[mkui](https://github.com/markuskimius/mkui) (config-driven Web Components
+workspace with dockable panes).
+
+Tasks live in a local SQLite database and show up in a live-updating blotter
+you can sort, filter, and arrange however you like. Each task carries an
+importance and an urgency (1–5); the blotter derives a score from them so the
+most pressing work floats to the top.
+
+## Quick start
+
+```bash
+pip install mktask
+mktask                    # http://127.0.0.1:8080/
+```
+
+Everything installs via `pip`; nothing is fetched at runtime.
+
+## CLI
+
+```
+mktask [config] [-p PORT] [--host HOST] [-d PATH] [--version]
+```
+
+- `config` — path to a `mktask.toml`. Defaults to `./mktask.toml` if
+  present, otherwise the one bundled with the package.
+- `-p, --port` — override the listening port (default 8080).
+- `--host` — override the listening host (default `127.0.0.1`).
+- `-d, --db` — database file; `.db` is appended when there is no
+  extension. `:memory:` runs without persistence.
+
+The server prints the URL to open once it is listening. If the port is
+already taken it exits immediately with an error instead of starting.
+
+## Customizing
+
+Copy the bundled config out and edit it:
+
+```bash
+python -c "import mktask, pathlib; print(pathlib.Path(mktask.__file__).parent / 'mktask.toml')"
+```
+
+`mktask.toml` declares the SQLite tables, the mkio services, and the static
+routes; `static/app.json` next to it declares the UI (menus, panes, frames,
+dialogs). Both are plain config — see the mkio and mkui READMEs for the
+formats.
+
+## Development
+
+```bash
+pip install -e '.[test]'
+mktask -d :memory:
+python -m pytest
+```
+
+The tests cover the CLI and config loading, a real server over HTTP and
+WebSocket (every task op, the query filter, saved layouts, the port and
+host flags), and the static integrity of `app.json` against `mktask.toml`.
+
+## License
+
+Apache License 2.0. See [LICENSE](LICENSE).

mktask-0.1.0/PLAN.md

@@ -0,0 +1,198 @@
+# mktask — skeleton application plan
+
+mktask is a work-task prioritizer built on [mkio](https://github.com/markuskimius/mkio)
+(TOML-driven backend: SQLite + WebSocket services) and
+[mkui](https://github.com/markuskimius/mkui) (config-driven Web Components
+workspace). Apache-2.0, published to PyPI as `mktask` (name is free on PyPI
+as of 2026-09-05).
+
+The structure follows `../mkfix`, the same author's existing mkio+mkui app:
+one Python package that bundles its server TOML and static UI, a `mktask`
+console script that runs the server, and mkui's assets served from the
+installed package rather than copied into the repo.
+
+**Status (2026-09-05):** All five phases are done. v0.1.0 is published to PyPI
+and the repo is on GitHub; 75 tests pass and the UI was exercised end to end
+in a browser.
+
+## Target layout
+
+```
+mktask/
+  __init__.py          __version__ (single source of truth) + lazy serve()
+  __main__.py          CLI (argparse) → mkio create_app(); resolves "__mkui__"
+  mktask.toml          tables, services, static routes (no version key)
+  static/
+    index.html         loads /mkui/src/index.js, fetches app.json, sets mkio.url
+    app.json           mkui config: menubar, statusbar, panes, frames, layouts
+    mktask.css         app-specific overrides (may start empty)
+tests/
+  test_cli.py          --help, --version, bad config path
+  test_server.py       boots on a free port with -d :memory:, exercises services over WS
+  test_ui_config.py    app.json integrity: pane refs, service names, index.html imports
+pyproject.toml         hatchling, dynamic version, deps mkio>=0.2.0 mkui>=0.2.9
+LICENSE                Apache-2.0
+README.md              badges, quick start, screenshot placeholder
+CLAUDE.md              project notes for future sessions
+.gitignore             __pycache__, *.db*, *.egg-info, dist/, build/
+```
+
+## Phase 1 — repository scaffolding
+
+1. `LICENSE`: Apache License 2.0 full text, copyright Mark Kim.
+2. `pyproject.toml`: hatchling build; `name = "mktask"`, `dynamic = ["version"]`
+   read from `mktask/__init__.py`; `license = "Apache-2.0"`;
+   `requires-python = ">=3.11"` (mkio's floor); deps `mkio>=0.2.0`,
+   `mkui>=0.2.9`; optional `test = [pytest, pytest-asyncio, pytest-aiohttp]`;
+   `[project.scripts] mktask = "mktask.__main__:main"`; classifiers include
+   `License :: OSI Approved :: Apache Software License` and
+   `Development Status :: 3 - Alpha`; URLs to github.com/markuskimius/mktask.
+   Hatch includes non-.py files under the package by default, so
+   `mktask.toml` and `static/` ship in the wheel without extra config.
+3. `mktask/__init__.py`: `__version__ = "0.1.0"` and a lazy `serve()` wrapper.
+4. `.gitignore`, `README.md` (short for now), `CLAUDE.md` (layout + commands).
+5. Install editable: `pip install -e '.[test]'`. Commit as "Scaffold package".
+
+## Phase 2 — server (`mktask.toml` + `__main__.py`)
+
+Data model for the skeleton. Keep it deliberately small; the prioritization
+model is the app's real subject and should be designed after the skeleton
+runs.
+
+```toml
+name = "mktask"
+port = 8080
+host = "127.0.0.1"        # personal tool: loopback by default
+db_path = "mktask.db"
+auto_migrate = true
+
+[tables.tasks]
+columns = { id = "INTEGER PRIMARY KEY AUTOINCREMENT",
+            title = "TEXT NOT NULL",
+            notes = "TEXT DEFAULT ''",
+            status = "TEXT NOT NULL DEFAULT 'open'",     # open | done
+            importance = "INTEGER NOT NULL DEFAULT 3",   # 1..5
+            urgency = "INTEGER NOT NULL DEFAULT 3",      # 1..5
+            due = "TEXT DEFAULT ''",                     # ISO date or ''
+            created_at = "TEXT DEFAULT CURRENT_TIMESTAMP",
+            updated_at = "TEXT DEFAULT CURRENT_TIMESTAMP",
+            done_at = "TEXT DEFAULT ''" }
+
+[tables.mkui_layouts]   # copied verbatim from mkui's scaffold (saved layouts)
+```
+
+Services:
+
+- `tasks` — `protocol = "transaction"` with ops `add` (insert: title, notes,
+  importance, urgency, due, with explicit `defaults` for every optional
+  field), `edit` (update by id), `done` (update status/done_at by id),
+  `reopen`, `delete` (by id). One transaction service with several ops keeps
+  the UI's action names in one place.
+- `all_tasks` — `protocol = "query"`, `primary_table = "tasks"`,
+  `filterable = ["status"]`. The blotter subscribes to this.
+- `mkui_layouts`, `mkui_layouts_list`, `mkui_layouts_get` — verbatim from
+  mkui's `init` scaffold so the Layout menu works. mkfix runs without login
+  and stores layouts under owner `''`; do the same.
+
+Static routes: `"/" = "./static"`, `"/mkui" = "__mkui__"`. No `[config]`
+route: like mkfix, the UI is JSON (`app.json`) fetched by `index.html`, so
+no TOML→JSON serving is needed.
+
+`__main__.py` mirrors mkfix's without the FIX engine:
+
+- `_load_config(path)`: `mkio.config.load_config`, inject
+  `cfg["version"] = __version__`, resolve `"__mkui__"` to `mkui.static_dir`
+  and relative static dirs against the TOML's directory.
+- `_find_config()`: `./mktask.toml` if present, else the packaged one. This
+  lets a user copy the TOML out and customize it.
+- `serve(config, host, port, db_path)`: `create_app(cfg)` then `app.run()`.
+  Skip mkfix's port pre-probe and custom banner initially; add them only if
+  the default `run()` output proves insufficient.
+- `main()`: positional optional `config`, `-p/--port`, `--host`, `-d/--db`
+  (`.db` appended when no suffix, `:memory:` passthrough), `--version`.
+
+Verify: `mktask -d :memory:` serves `http://127.0.0.1:8080/`, `/mkui/src/index.js`
+returns JS, and `mkio ls` (or a WS client) lists the services. Commit.
+
+## Phase 3 — UI (`static/`)
+
+`index.html`: copy mkfix's pattern — import `/mkui/src/index.js`, fetch
+`app.json` with `cache: "no-cache"`, set `config.mkio.url` from
+`location.host`, call `setConfig`. No custom pane modules yet.
+
+`app.json`:
+
+- `app`: title "mktask", theme dark.
+- `state`: `status.message/background/color`, `selected_task: null`.
+- `menubar`: Edit (copy, select all), Tasks (Open Tasks, All Tasks, Done via
+  `pane.show`; a `table.filter` entry "Hide done"), Layout (save, restore
+  submenu, reset), Window (cascade, tile submenu, `windows: true`).
+- `statusbar`: left `status.message`; right version text; `bindStyle` on
+  `status.*`.
+- `mkio`: `connected`/`disconnected` state maps; `expect = { name = "mktask" }`
+  (do not pin `version`, mkfix's tests exist precisely because a pinned
+  version leaks past releases).
+- `layouts`: `{ keep = 10, keepDays = 7 }`.
+- `panes.tasks`: `mkio-table` on `all_tasks`, columns id, title, importance,
+  urgency, score, due, status, created_at; `values.score` derives
+  `importance * urgency` as a virtual column (listed in `columns`);
+  `sort = "-score"`; `filters.status = ["open"]`; `rowStyle` greys done
+  rows; `select = { state = "selected_task" }`.
+  Toolbar buttons: "+ Add Task" (dialog → `tasks` op `add`), "Edit"
+  (`unit = "row"`, dialog prefilled from the row → op `edit`), "Done"
+  (`unit = "rows"`, transaction op `done`, `enable.when` status == open),
+  "Reopen", "Delete" (transaction op `delete`, confirm). Copy the dialog and
+  transaction action shapes from mkfix's `app.json` and mkui's `init`
+  scaffold.
+- `panes.task-detail`: a `text` widget bound to `selected_task.notes` as a
+  placeholder for a future custom pane.
+- `frames`: one main frame with tasks (0.03, 0.05, 0.64, 0.9) and one aux
+  frame with task-detail.
+
+`mktask.css`: empty file with a comment, imported by index.html so the hook
+exists.
+
+Verify in a browser: add, edit, complete, reopen, delete a task; rows
+flash live; saved layouts round-trip after reload. Commit.
+
+## Phase 4 — tests
+
+- `test_cli.py`: as mkfix's — help text, version string, nonexistent
+  config exits non-zero.
+- `test_server.py`: module-scoped fixture launches `python -m mktask -d
+  :memory: -p <free port>`; assert `/` and `/mkui/src/index.js` are 200;
+  over WS, `add` a task then `all_tasks` query returns it; `done` flips
+  status; `delete` removes it.
+- `test_ui_config.py`: every `pane.show` arg and frame layout child names a
+  pane; every `mkio-table` `service` and every transaction/dialog service
+  exists in `mktask.toml`; every `import "..."` in index.html resolves under
+  `static/` or `/mkui/`; `mkio.expect` has no `version`.
+
+`python -m pytest` green. Commit.
+
+## Phase 5 — publish
+
+1. README: badges (PyPI, Python, License), one-paragraph pitch, quick start
+   (`pip install mktask` / `mktask`), CLI flags, how to customize the TOML,
+   screenshot placeholder, license section.
+2. Tag `v0.1.0`; `python -m build`; upload to TestPyPI first, install into a
+   clean venv, run `mktask -d :memory:`; then `twine upload dist/*`.
+3. Create the GitHub repo `markuskimius/mktask`, push, add the PyPI link.
+
+## Deferred (not in the skeleton)
+
+- The prioritization model itself: weighted scoring, Eisenhower quadrants,
+  aging/due-date decay, projects/tags, recurring tasks. The `score` derived
+  column is the placeholder where this lands; it may move server-side into a
+  `reqrep` or computed column later.
+- Custom pane types (task detail editor, quadrant board, calendar).
+- Authentication (mkui `auth` + mkio `_mkio_users`) if the app is ever
+  multi-user; the per-owner layouts scaffold already supports it.
+- CI workflow (mkui and mkfix have none; add GitHub Actions if wanted).
+
+## Assumptions to confirm
+
+- Python >= 3.11 is acceptable (forced by mkio).
+- Single-user, no login, loopback host by default.
+- `importance`/`urgency` 1..5 integers are a fine placeholder schema for the
+  skeleton; the real model comes later.

mktask-0.1.0/README.md

@@ -0,0 +1,69 @@
+# mktask
+
+[![PyPI](https://img.shields.io/pypi/v/mktask)](https://pypi.org/project/mktask/)
+[![Python](https://img.shields.io/pypi/pyversions/mktask)](https://pypi.org/project/mktask/)
+[![License](https://img.shields.io/pypi/l/mktask)](https://github.com/markuskimius/mktask/blob/main/LICENSE)
+
+A work task prioritizer built on [mkio](https://github.com/markuskimius/mkio)
+(config-driven microservice backend) and
+[mkui](https://github.com/markuskimius/mkui) (config-driven Web Components
+workspace with dockable panes).
+
+Tasks live in a local SQLite database and show up in a live-updating blotter
+you can sort, filter, and arrange however you like. Each task carries an
+importance and an urgency (1–5); the blotter derives a score from them so the
+most pressing work floats to the top.
+
+## Quick start
+
+```bash
+pip install mktask
+mktask                    # http://127.0.0.1:8080/
+```
+
+Everything installs via `pip`; nothing is fetched at runtime.
+
+## CLI
+
+```
+mktask [config] [-p PORT] [--host HOST] [-d PATH] [--version]
+```
+
+- `config` — path to a `mktask.toml`. Defaults to `./mktask.toml` if
+  present, otherwise the one bundled with the package.
+- `-p, --port` — override the listening port (default 8080).
+- `--host` — override the listening host (default `127.0.0.1`).
+- `-d, --db` — database file; `.db` is appended when there is no
+  extension. `:memory:` runs without persistence.
+
+The server prints the URL to open once it is listening. If the port is
+already taken it exits immediately with an error instead of starting.
+
+## Customizing
+
+Copy the bundled config out and edit it:
+
+```bash
+python -c "import mktask, pathlib; print(pathlib.Path(mktask.__file__).parent / 'mktask.toml')"
+```
+
+`mktask.toml` declares the SQLite tables, the mkio services, and the static
+routes; `static/app.json` next to it declares the UI (menus, panes, frames,
+dialogs). Both are plain config — see the mkio and mkui READMEs for the
+formats.
+
+## Development
+
+```bash
+pip install -e '.[test]'
+mktask -d :memory:
+python -m pytest
+```
+
+The tests cover the CLI and config loading, a real server over HTTP and
+WebSocket (every task op, the query filter, saved layouts, the port and
+host flags), and the static integrity of `app.json` against `mktask.toml`.
+
+## License
+
+Apache License 2.0. See [LICENSE](LICENSE).

mktask-0.1.0/mktask/__init__.py

@@ -0,0 +1,8 @@
+"""mktask — work task prioritizer built on mkio and mkui."""
+
+__version__ = "0.1.0"
+
+
+def serve(config="mktask.toml", host=None, port=None, db_path=None):
+    from mktask.__main__ import serve as _serve
+    _serve(config, host=host, port=port, db_path=db_path)