abstractnote 0.1.0__tar.gz

abstractnote-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Laurent-Philippe Albou
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

abstractnote-0.1.0/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: abstractnote
+Version: 0.1.0
+Summary: AbstractNote: one endpoint for your notes; a temporal semantic knowledge graph of your life, built on AbstractGateway, AbstractRuntime and AbstractMemory
+Author-email: Laurent-Philippe Albou <contact@abstractcore.ai>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/lpalbou/abstractnote
+Project-URL: Repository, https://github.com/lpalbou/abstractnote
+Project-URL: Issues, https://github.com/lpalbou/abstractnote/issues
+Keywords: notes,knowledge-graph,memory,temporal,abstractframework
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: abstractmemory>=0.3.1
+Requires-Dist: abstractsemantics>=0.0.5
+Requires-Dist: abstractruntime>=0.10.2
+Requires-Dist: abstractcore>=2.26.3
+Requires-Dist: pydantic>=2.0
+Provides-Extra: gateway
+Requires-Dist: abstractgateway>=0.15.11; extra == "gateway"
+Requires-Dist: fastapi>=0.110; extra == "gateway"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.1; extra == "dev"
+Dynamic: license-file
+
+# AbstractNote
+
+One endpoint for everything you want to remember. Send a sentence, a document, a photo, a
+recording, a log. AbstractNote files it with its time, place and provenance, links it to what
+you already know, and grows a **temporal semantic knowledge graph** of your ideas, projects,
+people and decisions. You search it by effort (quick, standard, deep) and revisit it through
+time: what you knew, when you learned it, and how your view changed.
+
+AbstractNote is part of the AbstractFramework. It runs on **AbstractGateway** (sign-in, one
+runtime and one notebook per user, app hosting), **AbstractRuntime** and **AbstractFlow** (the
+capture and understanding workflows), **AbstractMemory** (temporal facts) and **AbstractCore**
+(models, structured output, embeddings).
+
+Status: version 0.1.0, in development. It is not published on PyPI or npm yet; you install it
+from source (see [Install](#install)).
+
+## What you get
+
+- **Capture anywhere**: the web app, the Apple Watch app, the `abstractnote` command line, and
+  agents. Attachments are de-duplicated by content; a retried send never saves a note twice.
+- **Automatic filing**: a small fast model gives each note a title, a kind, topics, an urgency
+  and its language, next to the time and place it was made.
+- **Self-organising knowledge**: a model resolves people, projects and ideas against candidates
+  that exact lookups, full-text and vectors produce. Every change is a revision you can replay,
+  and every claim keeps the note it came from.
+- **Remember by cue and effort**: quick (no model, under a second), standard (one synthesis with
+  citations), deep (a background dossier). Then-versus-now for any person, project, idea or link.
+- **Reflection**: open loops, contradictions, things that went quiet and connections you may have
+  missed, surfaced as insights.
+- **Imports**: Claude Code sessions, an agora hub database, Markdown trees and plain files, with
+  their original dates and provenance.
+
+## Install
+
+AbstractNote needs Python 3.10 or later and the framework packages next to it. Until the
+packages are published, install everything from source checkouts:
+
+```sh
+python3 -m venv .venv
+.venv/bin/pip install -e ../abstractsemantics -e ../abstractcore -e ../abstractruntime \
+                      -e ../abstractmemory     # a checkout that has close_assertion, see below
+.venv/bin/pip install -e .
+.venv/bin/abstractnote --help
+```
+
+Two framework changes that AbstractNote relies on are not in released packages yet:
+
+- **AbstractMemory `close_assertion`** (the `close-assertion` branch): closes a superseded fact in
+  place. AbstractNote's first release waits for the AbstractMemory release that contains it.
+- **The AbstractGateway integration** (the `abstractnote-seam` branch): binds the note tools to
+  each user's notebook, serves the note read API and lists the Note app. You need it only for the
+  gateway path; the headless notebook works without a gateway. The gateway must carry this seam
+  (`abstractgateway.abstractnote_seam`; the first gateway release with it is named at
+  AbstractNote's release): the `[gateway]` extra alone does not guarantee it, and
+  `abstractnote.gateway` refuses to import into a gateway without it, with one sentence.
+
+To run models locally on Apple silicon, add `pip install "abstractcore[apple]"` (MLX).
+
+## Quick start
+
+A headless notebook on this machine, no gateway and no model:
+
+```sh
+abstractnote capture "Met Dana about the LUT budget; she wants the Pareto by Friday." --notebook ~/notes
+abstractnote search "LUT budget" --notebook ~/notes
+abstractnote status --notebook ~/notes
+```
+
+Let a model understand the queued notes (entities, claims, tasks), then ask a question:
+
+```sh
+abstractnote process --local --notebook ~/notes --provider mlx --model mlx-community/Qwen3.6-35B-A3B-4bit
+abstractnote search "What does Dana want?" --effort standard --notebook ~/notes \
+    --provider mlx --model mlx-community/Qwen3.6-35B-A3B-4bit
+```
+
+A notebook is pinned to the embedding model that created it. Choose it on the first command
+(`--embed-base-url` and `--embed-model`, for example a local LM Studio embedding model) and give
+the same flags every time, or start with the built-in offline embedder and change later with
+`abstractnote rebuild --reembed`. See [docs/getting-started.md](docs/getting-started.md).
+
+Through a gateway, clients start the `note-capture` and `note-recall` flows with the gateway's
+runs API, and `POST /api/gateway/note/processor/ensure` creates the per-user processor that
+understands notes in the background. The getting-started guide walks through a private scratch
+gateway, the web app and the watch app.
+
+## Clients
+
+| Client | Where | What it does |
+|---|---|---|
+| Web app | [`web/`](web/) (`@abstractframework/note`) | Capture (a chat with attachments), Graph (entities and links through time), Remember (since you last looked, cue cards, ask by effort, then and now), Settings |
+| Apple Watch app | [`watch/apple/`](watch/apple/README.md) | Note, Ask, Today, Settings; watch-only, watchOS 26 or later |
+| Command line | `abstractnote` | Headless capture, search, processing, imports, rebuild, JSON output for scripts and agents |
+
+An iPhone app is planned ([`phone/iphone/`](phone/iphone/README.md)). Agents use the same note
+tools and flows, with the effort level as a parameter.
+
+## Documentation
+
+- [docs/README.md](docs/README.md): the documentation index
+- [Getting started](docs/getting-started.md): a headless notebook in five minutes, then the gateway path
+- [Architecture](docs/architecture.md): components, data plane, request lifecycles
+- [API](docs/api.md): runs API usage, note read API, note tools, Python API, CLI
+- [Data model](docs/data-model.md), [Cognition](docs/cognition.md), [Remembering](docs/remembering.md),
+  [Clients](docs/clients.md), [Importers](docs/importers.md)
+- [FAQ](docs/faq.md) and [Troubleshooting](docs/troubleshooting.md)
+- [Contributing](CONTRIBUTING.md), [Security](SECURITY.md), [Changelog](CHANGELOG.md),
+  [Acknowledgements](ACKNOWLEDGEMENTS.md)
+
+## License
+
+MIT. See [LICENSE](LICENSE).

abstractnote-0.1.0/README.md

@@ -0,0 +1,112 @@
+# AbstractNote
+
+One endpoint for everything you want to remember. Send a sentence, a document, a photo, a
+recording, a log. AbstractNote files it with its time, place and provenance, links it to what
+you already know, and grows a **temporal semantic knowledge graph** of your ideas, projects,
+people and decisions. You search it by effort (quick, standard, deep) and revisit it through
+time: what you knew, when you learned it, and how your view changed.
+
+AbstractNote is part of the AbstractFramework. It runs on **AbstractGateway** (sign-in, one
+runtime and one notebook per user, app hosting), **AbstractRuntime** and **AbstractFlow** (the
+capture and understanding workflows), **AbstractMemory** (temporal facts) and **AbstractCore**
+(models, structured output, embeddings).
+
+Status: version 0.1.0, in development. It is not published on PyPI or npm yet; you install it
+from source (see [Install](#install)).
+
+## What you get
+
+- **Capture anywhere**: the web app, the Apple Watch app, the `abstractnote` command line, and
+  agents. Attachments are de-duplicated by content; a retried send never saves a note twice.
+- **Automatic filing**: a small fast model gives each note a title, a kind, topics, an urgency
+  and its language, next to the time and place it was made.
+- **Self-organising knowledge**: a model resolves people, projects and ideas against candidates
+  that exact lookups, full-text and vectors produce. Every change is a revision you can replay,
+  and every claim keeps the note it came from.
+- **Remember by cue and effort**: quick (no model, under a second), standard (one synthesis with
+  citations), deep (a background dossier). Then-versus-now for any person, project, idea or link.
+- **Reflection**: open loops, contradictions, things that went quiet and connections you may have
+  missed, surfaced as insights.
+- **Imports**: Claude Code sessions, an agora hub database, Markdown trees and plain files, with
+  their original dates and provenance.
+
+## Install
+
+AbstractNote needs Python 3.10 or later and the framework packages next to it. Until the
+packages are published, install everything from source checkouts:
+
+```sh
+python3 -m venv .venv
+.venv/bin/pip install -e ../abstractsemantics -e ../abstractcore -e ../abstractruntime \
+                      -e ../abstractmemory     # a checkout that has close_assertion, see below
+.venv/bin/pip install -e .
+.venv/bin/abstractnote --help
+```
+
+Two framework changes that AbstractNote relies on are not in released packages yet:
+
+- **AbstractMemory `close_assertion`** (the `close-assertion` branch): closes a superseded fact in
+  place. AbstractNote's first release waits for the AbstractMemory release that contains it.
+- **The AbstractGateway integration** (the `abstractnote-seam` branch): binds the note tools to
+  each user's notebook, serves the note read API and lists the Note app. You need it only for the
+  gateway path; the headless notebook works without a gateway. The gateway must carry this seam
+  (`abstractgateway.abstractnote_seam`; the first gateway release with it is named at
+  AbstractNote's release): the `[gateway]` extra alone does not guarantee it, and
+  `abstractnote.gateway` refuses to import into a gateway without it, with one sentence.
+
+To run models locally on Apple silicon, add `pip install "abstractcore[apple]"` (MLX).
+
+## Quick start
+
+A headless notebook on this machine, no gateway and no model:
+
+```sh
+abstractnote capture "Met Dana about the LUT budget; she wants the Pareto by Friday." --notebook ~/notes
+abstractnote search "LUT budget" --notebook ~/notes
+abstractnote status --notebook ~/notes
+```
+
+Let a model understand the queued notes (entities, claims, tasks), then ask a question:
+
+```sh
+abstractnote process --local --notebook ~/notes --provider mlx --model mlx-community/Qwen3.6-35B-A3B-4bit
+abstractnote search "What does Dana want?" --effort standard --notebook ~/notes \
+    --provider mlx --model mlx-community/Qwen3.6-35B-A3B-4bit
+```
+
+A notebook is pinned to the embedding model that created it. Choose it on the first command
+(`--embed-base-url` and `--embed-model`, for example a local LM Studio embedding model) and give
+the same flags every time, or start with the built-in offline embedder and change later with
+`abstractnote rebuild --reembed`. See [docs/getting-started.md](docs/getting-started.md).
+
+Through a gateway, clients start the `note-capture` and `note-recall` flows with the gateway's
+runs API, and `POST /api/gateway/note/processor/ensure` creates the per-user processor that
+understands notes in the background. The getting-started guide walks through a private scratch
+gateway, the web app and the watch app.
+
+## Clients
+
+| Client | Where | What it does |
+|---|---|---|
+| Web app | [`web/`](web/) (`@abstractframework/note`) | Capture (a chat with attachments), Graph (entities and links through time), Remember (since you last looked, cue cards, ask by effort, then and now), Settings |
+| Apple Watch app | [`watch/apple/`](watch/apple/README.md) | Note, Ask, Today, Settings; watch-only, watchOS 26 or later |
+| Command line | `abstractnote` | Headless capture, search, processing, imports, rebuild, JSON output for scripts and agents |
+
+An iPhone app is planned ([`phone/iphone/`](phone/iphone/README.md)). Agents use the same note
+tools and flows, with the effort level as a parameter.
+
+## Documentation
+
+- [docs/README.md](docs/README.md): the documentation index
+- [Getting started](docs/getting-started.md): a headless notebook in five minutes, then the gateway path
+- [Architecture](docs/architecture.md): components, data plane, request lifecycles
+- [API](docs/api.md): runs API usage, note read API, note tools, Python API, CLI
+- [Data model](docs/data-model.md), [Cognition](docs/cognition.md), [Remembering](docs/remembering.md),
+  [Clients](docs/clients.md), [Importers](docs/importers.md)
+- [FAQ](docs/faq.md) and [Troubleshooting](docs/troubleshooting.md)
+- [Contributing](CONTRIBUTING.md), [Security](SECURITY.md), [Changelog](CHANGELOG.md),
+  [Acknowledgements](ACKNOWLEDGEMENTS.md)
+
+## License
+
+MIT. See [LICENSE](LICENSE).

abstractnote-0.1.0/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "abstractnote"
+version = "0.1.0"
+description = "AbstractNote: one endpoint for your notes; a temporal semantic knowledge graph of your life, built on AbstractGateway, AbstractRuntime and AbstractMemory"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{name = "Laurent-Philippe Albou", email = "contact@abstractcore.ai"}]
+keywords = ["notes", "knowledge-graph", "memory", "temporal", "abstractframework"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: End Users/Desktop",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "abstractmemory>=0.3.1",
+    "abstractsemantics>=0.0.5",
+    "abstractruntime>=0.10.2",
+    "abstractcore>=2.26.3",
+    "pydantic>=2.0",
+]
+
+[project.optional-dependencies]
+# The gateway must carry the AbstractNote seam (abstractgateway.abstractnote_seam); no released
+# AbstractGateway has it yet, so this floor is raised to the first release that does when
+# AbstractNote is released. Until then abstractnote.gateway refuses to import without the seam.
+gateway = ["abstractgateway>=0.15.11", "fastapi>=0.110"]
+dev = ["pytest>=7.0", "ruff>=0.1"]
+
+[project.scripts]
+abstractnote = "abstractnote.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/lpalbou/abstractnote"
+Repository = "https://github.com/lpalbou/abstractnote"
+Issues = "https://github.com/lpalbou/abstractnote/issues"
+
+[tool.setuptools.package-dir]
+"" = "src"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["abstractnote*"]
+
+[tool.setuptools.package-data]
+abstractnote = ["flows/json/*.json", "process/prompts/*.md"]
+
+[tool.ruff]
+line-length = 110
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

abstractnote-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

abstractnote-0.1.0/src/abstractnote/__init__.py

@@ -0,0 +1,18 @@
+"""AbstractNote: one endpoint for your notes; a temporal semantic knowledge graph of your life.
+
+``Notebook.open(dir)`` opens a notebook directory; ``abstractnote.tools.bind(dir)``
+returns the note tools for flows and agents.
+"""
+
+__version__ = "0.1.0"
+
+
+def __getattr__(name: str):  # lazy: importing abstractnote stays cheap
+    if name == "Notebook":
+        from .store.notebook import Notebook
+
+        return Notebook
+    raise AttributeError(name)
+
+
+__all__ = ["Notebook", "__version__"]

abstractnote-0.1.0/src/abstractnote/cli.py

@@ -0,0 +1,240 @@
+"""The ``abstractnote`` command line (docs/api.md, "CLI").
+
+Every command works on a notebook directory with ``--notebook DIR`` (inside a
+gateway the notebook is ``<gateway data dir>/abstractnote``, or
+``<data dir>/users/<tenant>/<runtime>/abstractnote`` for a user plane).
+``--gateway URL --token T`` client mode is not available yet and says so.
+Output is JSON on stdout. Exit codes: 0 done, 2 bad input, 3 a part of
+AbstractNote that is not installed or not available yet.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+EXIT_OK, EXIT_INPUT, EXIT_GAP = 0, 2, 3
+
+
+class Gap(RuntimeError):
+    """A piece the command needs is not available (another package part, or client mode)."""
+
+
+def _emit(data: Any) -> None:
+    print(json.dumps(data, indent=2, ensure_ascii=False, default=str))
+
+
+def _common(p: argparse.ArgumentParser) -> None:
+    p.add_argument("--notebook", type=Path, help="notebook directory (created when missing)")
+    p.add_argument("--gateway", help="gateway URL (client mode)")
+    p.add_argument("--token", help="gateway token, passed directly")
+    p.add_argument("--embed-base-url", help="OpenAI-compatible embeddings URL (for example http://127.0.0.1:1234/v1). "
+                   "A notebook is pinned to its embedding model when it is created (by the first command that "
+                   "opens it, capture included; without these flags: the built-in hashing embedder); every later "
+                   "command must give the same model, or run rebuild --reembed to change it")
+    p.add_argument("--embed-model", help="embedding model id at that URL (pinned at notebook creation, see --embed-base-url)")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    ap = argparse.ArgumentParser(prog="abstractnote", description="AbstractNote: one endpoint for your notes.")
+    sub = ap.add_subparsers(dest="command", required=True)
+
+    p = sub.add_parser("capture", help="save a note now")
+    _common(p)
+    p.add_argument("text", nargs="?", default="")
+    p.add_argument("--file", action="append", default=[], type=Path, help="attach a file (repeatable)")
+    p.add_argument("--at", help="when it happened (ISO 8601; default now)")
+    p.add_argument("--title")
+    p.add_argument("--priority", type=int, choices=[0, 1, 2, 3])
+    p.add_argument("--key", help="idempotency key (a retry with the same key saves nothing new)")
+
+    p = sub.add_parser("search", help="search the notes")
+    _common(p)
+    p.add_argument("query")
+    p.add_argument("--effort", choices=["quick", "standard", "deep"], default="quick")
+    p.add_argument("--since")
+    p.add_argument("--until")
+    p.add_argument("--as-of")
+    p.add_argument("--limit", type=int, default=20)
+    p.add_argument("--provider", help="model provider for standard and deep effort")
+    p.add_argument("--model", help="model for standard and deep effort")
+
+    p = sub.add_parser("entity", help="an entity card")
+    _common(p)
+    p.add_argument("entity_id")
+    p.add_argument("--at")
+
+    p = sub.add_parser("day", help="what happened on a day")
+    _common(p)
+    p.add_argument("date", help="YYYY-MM-DD")
+    p.add_argument("--tz")
+
+    p = sub.add_parser("status", help="notebook counts, queue and versions")
+    _common(p)
+
+    p = sub.add_parser("changes", help="what changed since a cursor or a time")
+    _common(p)
+    p.add_argument("--since")
+    p.add_argument("--limit", type=int, default=50)
+
+    p = sub.add_parser("rebuild", help="replay revisions into fresh index and triple stores")
+    _common(p)
+    p.add_argument("--reembed", action="store_true", help="recompute every vector with the given embedder")
+
+    p = sub.add_parser("process", help="process queued notes now")
+    _common(p)
+    p.add_argument("--local", action="store_true", help="run the flows here (headless)")
+    p.add_argument("--provider")
+    p.add_argument("--model")
+    p.add_argument("--max-items", type=int, default=20)
+    p.add_argument("--budget-s", type=float, default=90.0)
+
+    p = sub.add_parser("bundle", help="pack the abstractnote .flow bundle")
+    p.add_argument("--out", type=Path, default=Path("."))
+
+    p = sub.add_parser("processor", help="processor automation")
+    _common(p)
+    p.add_argument("action", choices=["ensure"])
+
+    sub.add_parser("import", help="import a corpus (claude-sessions, agora, markdown, files)", add_help=False)
+    return ap
+
+
+def _embedder(args: argparse.Namespace) -> Any:
+    if getattr(args, "embed_base_url", None) or getattr(args, "embed_model", None):
+        if not (args.embed_base_url and args.embed_model):
+            raise ValueError("Give both --embed-base-url and --embed-model.")
+        from .store.embeddings import openai_compat_embedder
+
+        return openai_compat_embedder(args.embed_base_url, args.embed_model)
+    return None
+
+
+def _client_mode(args: argparse.Namespace) -> None:
+    if getattr(args, "gateway", None):
+        raise NotImplementedError(
+            "Gateway client mode is not available in this version; run the command on the machine that holds the "
+            "notebook with --notebook DIR.")
+
+
+def _open(args: argparse.Namespace) -> Any:
+    _client_mode(args)
+    if not getattr(args, "notebook", None):
+        raise ValueError("Say which notebook with --notebook DIR (a gateway keeps it in <data dir>/abstractnote).")
+    from .store.notebook import Notebook
+
+    return Notebook.open(args.notebook, embedder=_embedder(args))
+
+
+def _cmd_capture(args: argparse.Namespace) -> Any:
+    files = []
+    for path in args.file:
+        if not path.is_file():
+            raise ValueError(f"There is no file at {path}.")
+        files.append({"data": path.read_bytes(), "filename": path.name})
+    with _open(args) as nb:
+        return nb.capture(args.text, title=args.title, occurred_at=args.at, priority=args.priority,
+                          idempotency_key=args.key, attachments=files, source={"client": "cli"}).model_dump()
+
+
+def _runner(args: argparse.Namespace) -> Any:
+    try:
+        from .flows.runner import NoteRunner
+    except ImportError as exc:
+        raise Gap(f"The flows are not installed with this AbstractNote ({exc}).") from None
+    if not (args.provider and args.model):
+        raise ValueError("Give --provider and --model for the model that processes or answers.")
+    return NoteRunner.local(args.notebook, provider=args.provider, model=args.model, embedder=_embedder(args))
+
+
+def _cmd_search(args: argparse.Namespace) -> Any:
+    if args.effort == "quick":
+        with _open(args) as nb:
+            return nb.search(args.query, since=args.since, until=args.until, as_of=args.as_of, limit=args.limit)
+    _client_mode(args)
+    if not args.notebook:
+        raise ValueError("Say which notebook with --notebook DIR.")
+    return _runner(args).run_recall(args.query, effort=args.effort, since=args.since, until=args.until,
+                                    as_of=args.as_of)
+
+
+def _cmd_process(args: argparse.Namespace) -> Any:
+    _client_mode(args)
+    if not args.local:
+        raise NotImplementedError("Processing through a gateway is not available here; use --local with "
+                                  "--provider and --model, or press Process now in the web app.")
+    if not args.notebook:
+        raise ValueError("Say which notebook with --notebook DIR.")
+    return _runner(args).run_drain(max_items=args.max_items, budget_s=args.budget_s)
+
+
+def _cmd_bundle(args: argparse.Namespace) -> Any:
+    try:
+        from .flows.bundle import pack
+    except ImportError as exc:
+        raise Gap(f"The flows are not installed with this AbstractNote ({exc}).") from None
+    try:
+        return {"bundle": str(pack(args.out, check_fresh=True))}
+    except RuntimeError as exc:  # stale generated flows: the flows must be rebuilt first
+        raise Gap(str(exc)) from None
+
+
+def _cmd_import(argv: List[str]) -> int:
+    try:
+        from .importers.cli import main as import_main
+    except ImportError as exc:
+        print(f"The importers are not installed with this AbstractNote ({exc}).", file=sys.stderr)
+        return EXIT_GAP
+    return int(import_main(argv, prog="abstractnote import") or 0)
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if argv[:1] == ["import"]:
+        return _cmd_import(argv[1:])
+    args = build_parser().parse_args(argv)
+    try:
+        if args.command == "capture":
+            out = _cmd_capture(args)
+        elif args.command == "search":
+            out = _cmd_search(args)
+        elif args.command == "entity":
+            with _open(args) as nb:
+                out = nb.entity(args.entity_id, at=args.at)
+        elif args.command == "day":
+            with _open(args) as nb:
+                out = nb.day(args.date, args.tz)
+        elif args.command == "status":
+            with _open(args) as nb:
+                out = nb.status()
+        elif args.command == "changes":
+            with _open(args) as nb:
+                out = nb.changes(args.since, args.limit)
+        elif args.command == "rebuild":
+            with _open(args) as nb:
+                out = nb.rebuild(reembed=args.reembed, embedder=_embedder(args))
+        elif args.command == "process":
+            out = _cmd_process(args)
+        elif args.command == "bundle":
+            out = _cmd_bundle(args)
+        elif args.command == "processor":
+            _client_mode(args)
+            raise NotImplementedError("Creating the processor needs a gateway: open the web app, or use "
+                                      "POST /api/gateway/note/processor/ensure with your token.")
+        else:  # pragma: no cover - argparse rejects unknown commands
+            raise ValueError(f"Unknown command {args.command}.")
+    except (NotImplementedError, Gap) as exc:
+        print(str(exc), file=sys.stderr)
+        return EXIT_GAP
+    except ValueError as exc:
+        print(str(exc), file=sys.stderr)
+        return EXIT_INPUT
+    _emit(out)
+    return EXIT_OK
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

abstractnote-0.1.0/src/abstractnote/flows/__init__.py

@@ -0,0 +1,2 @@
+"""AbstractNote flows: the VisualFlow generator (``build``), the bundle packer (``bundle``)
+and the headless runner (``runner``)."""