project-mgr 0.1.0

package/.env_sample

@@ -0,0 +1,5 @@
+# SQLite database path. Relative paths are resolved from the current directory.
+PMGR_DB_PATH=./data/project-mgr.sqlite
+
+# For isolated manual testing, use a separate database instead:
+# PMGR_DB_PATH=./data/manual-test.sqlite

package/.prettierignore

@@ -0,0 +1,4 @@
+dist
+coverage
+node_modules
+data

package/AGENTS.md

@@ -0,0 +1,5 @@
+# Project instructions
+
+Follow the user-level instructions in `~/.agents/AGENTS.md`.
+
+Unless the user explicitly requests another language, write project files, code comments, documentation, changelog entries, and agent-authored artifacts in English.

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+## Unreleased
+
+### Fixed
+
+- Approved the required `better-sqlite3` and `esbuild` build scripts for reproducible frozen pnpm installs.
+- Made empty human-readable list queries explicit while preserving `[]` JSON output.
+- Added top-level CLI action shorthand while keeping `status <action>` compatibility.
+
+## 0.1.0 - 2026-08-03
+
+### Added
+
+- A local TypeScript CLI and SQLite append-only project status ledger.
+- Single-record, JSON, and JSONL atomic writes; current, historical, and point-in-time queries; and restorable exports.
+- Strict input validation, `externalRef` idempotency, automatic migrations, and deterministic time ordering.
+- `.env_sample` and automatic loading of local `.env` database configuration by the run scripts.
+- English usage documentation and a standalone architecture document.
+- 100% coverage thresholds for statements, branches, functions, and lines.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dean
+
+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.

package/README.md

@@ -0,0 +1,184 @@
+# Project Manager
+
+[Chinese](README_CN.md)
+
+`project-mgr` is a local-first, append-only ledger for project status. It stores progress, blockers, decisions, and next steps as timestamped status snapshots, so people and AI agents can quickly inspect each project's current state, complete history, or state at a particular time.
+
+The first release provides only a local CLI and SQLite. It has no HTTP API, long-running service, or agent skills. Data stays on the local machine and requires no account or cloud service.
+
+## Install and run
+
+Requires Node.js 22+ and pnpm 10.30.2.
+
+```bash
+pnpm install --frozen-lockfile
+cp .env_sample .env
+pnpm build
+```
+
+`.env_sample` provides examples for all environment settings. The copied `.env` file is ignored by Git. `pnpm start` and `pnpm pmgr` automatically load the root `.env`; existing shell environment variables take precedence.
+
+After building, run:
+
+```bash
+pnpm start current
+```
+
+During development, run the TypeScript CLI directly:
+
+```bash
+pnpm pmgr current
+```
+
+The default configuration in `.env_sample` is:
+
+```dotenv
+PMGR_DB_PATH=./data/project-mgr.sqlite
+```
+
+Set `PMGR_DB_PATH` in `.env` to use another location, or override it for one command:
+
+```bash
+PMGR_DB_PATH=/absolute/path/projects.sqlite pnpm start current
+```
+
+Relative paths are resolved from the working directory of the command. When `pnpm start ...` runs from this project's root, the default database is `./data/project-mgr.sqlite`. It is created automatically when the first valid command runs.
+
+### Use an isolated test database
+
+For manual testing, set a persistent path in `.env` that is separate from production data:
+
+```dotenv
+PMGR_DB_PATH=./data/manual-test.sqlite
+```
+
+Then run commands normally:
+
+```bash
+pnpm start add \
+  --project test-project \
+  --status active \
+  --summary "Testing the isolated database"
+
+pnpm start history --project test-project
+```
+
+Project keys must match exactly: a record added to `test-project` is not part of `project-mgr` history. Empty human-readable list queries print `No entries found.`; with `--json`, they print `[]`.
+
+`data/` is ignored by Git, so test data is not committed. Delete `data/manual-test.sqlite` when it is no longer needed.
+
+Automated tests use an in-memory database or SQLite files in the system temporary directory; they do not read or write the default database. `PMGR_DB_PATH=:memory:` also works for one command, but each CLI command runs in a separate process and its data disappears when the command exits, so it is not suitable for consecutive manual tests.
+
+## Quick start
+
+Append a project status:
+
+```bash
+pnpm start add \
+  --project project-mgr \
+  --status active \
+  --summary "The local status ledger is available" \
+  --progress "Completed SQLite and CLI support" \
+  --next "Connect a real project" \
+  --tag mvp
+```
+
+Query the current status of all projects or one project:
+
+```bash
+pnpm start current
+pnpm start current --project project-mgr --json
+```
+
+Query history and the status at a specified time:
+
+```bash
+pnpm start history \
+  --project project-mgr \
+  --since 2026-08-01T00:00:00Z \
+  --limit 20 \
+  --offset 0
+
+pnpm start at \
+  --project project-mgr \
+  --at 2026-08-03T12:00:00+08:00 \
+  --json
+```
+
+## Write status
+
+`add` requires:
+
+- `--project`: Unique project name. It may contain English letters, numbers, `.`, `_`, and `-`, and must start with a letter or number.
+- `--status`: One of `idea`, `planned`, `active`, `blocked`, `paused`, `completed`, or `archived`.
+- `--summary`: A summary of this status.
+
+Optional arguments:
+
+- `--progress`: Work already completed.
+- `--blocker`, `--next`, `--decision`, and `--tag`: May be specified repeatedly.
+- `--at`: When the status actually occurred. It must be an ISO 8601 timestamp with a timezone; defaults to the current time.
+- `--source`: `human`, `agent`, or `import`; defaults to `human`.
+- `--external-ref`: A globally idempotent key. A duplicate write to the same project returns the existing record; use by another project is an error.
+- `--json`: Emit stable JSON.
+
+## Bulk import
+
+`import` accepts a JSON object, a JSON array, or a JSONL file containing one object per line. Every record is validated before the whole batch is written in one SQLite transaction; any failure rolls back the entire batch.
+
+```json
+{
+  "project": "project-mgr",
+  "status": "active",
+  "summary": "Core functionality is complete",
+  "progress": "CLI and SQLite have passed tests",
+  "blockers": [],
+  "nextSteps": ["Connect a real project"],
+  "decisions": ["The first release provides only a local CLI"],
+  "tags": ["mvp"],
+  "occurredAt": "2026-08-03T12:00:00+08:00",
+  "source": "human",
+  "externalRef": "project-mgr-2026-08-03-core"
+}
+```
+
+```bash
+pnpm start import statuses.jsonl
+# Equivalent form
+pnpm start import --file statuses.jsonl --json
+```
+
+Unknown fields, unknown CLI options, extra positional arguments, invalid statuses, and timestamps without a timezone are rejected.
+
+## Query and export
+
+| Command   | Purpose                                         | Key options                                                        |
+| --------- | ----------------------------------------------- | ------------------------------------------------------------------ |
+| `current` | Current status for all projects or one project  | `--project`, `--json`                                              |
+| `history` | One project's history, newest first             | `--project`, `--since`, `--until`, `--limit`, `--offset`, `--json` |
+| `at`      | The latest status at or before a specified time | `--project`, `--at`, `--json`                                      |
+| `export`  | Export all records or one project's records     | `--project`, `--format json\|jsonl`                                |
+
+All six actions can also use the compatible `status <action>` form, for example `pmgr status export`. Human-readable multi-record results list project, status, occurrence time, and summary, or `No entries found.` when empty. `add`, `import`, `current`, `history`, and `at` support `--json`; `export` uses `--format` to select its format.
+
+Exports omit the database-internal `id` and `recordedAt` fields and can be imported directly. Records are exported from oldest to newest so that restoring them preserves the insertion order of records with the same timestamp:
+
+```bash
+pnpm start export --format jsonl > project-statuses.jsonl
+
+PMGR_DB_PATH=./data/restored.sqlite \
+  pnpm start import project-statuses.jsonl
+```
+
+## Development and verification
+
+```bash
+pnpm typecheck
+pnpm lint
+pnpm format-check
+pnpm test
+pnpm coverage
+pnpm build
+```
+
+Coverage thresholds for statements, branches, functions, and lines are all 100%. See the [architecture document](docs/architecture.md) for the detailed design.

package/README_CN.md

@@ -0,0 +1,184 @@
+# Project Manager
+
+[English](README.md)
+
+`project-mgr` 是一个本地优先、只追加的项目状态账本。它把项目进展、阻塞、决策和下一步保存为带时间的状态快照，让个人或 AI Agent 能快速查询每个项目的当前状态、完整历史以及某个时间点的状态。
+
+首版只提供本地 CLI 和 SQLite，不包含 HTTP API、常驻服务或 Agent Skills。数据默认保存在本机，无需账号或云服务。
+
+## 安装与运行
+
+需要 Node.js 22+ 和 pnpm 10.30.2。
+
+```bash
+pnpm install --frozen-lockfile
+cp .env_sample .env
+pnpm build
+```
+
+`.env_sample` 提供全部环境配置示例；复制得到的 `.env` 已被 Git 忽略。`pnpm start` 和 `pnpm pmgr` 会自动读取项目根目录下的 `.env`，已有的 shell 环境变量优先级更高。
+
+构建后通过以下方式运行：
+
+```bash
+pnpm start current
+```
+
+开发时也可以直接运行 TypeScript：
+
+```bash
+pnpm pmgr current
+```
+
+默认配置位于 `.env_sample`：
+
+```dotenv
+PMGR_DB_PATH=./data/project-mgr.sqlite
+```
+
+通过 `.env` 中的 `PMGR_DB_PATH` 指定其他位置，也可以为单条命令临时覆盖：
+
+```bash
+PMGR_DB_PATH=/absolute/path/projects.sqlite pnpm start current
+```
+
+路径基于启动命令的当前工作目录计算。从本项目根目录执行 `pnpm start ...` 时，默认位置就是 `./data/project-mgr.sqlite`。数据库会在第一次执行有效命令时自动创建。
+
+### 使用独立测试数据库
+
+手工测试时，建议在 `.env` 中固定设置一个与正式数据分离的路径：
+
+```dotenv
+PMGR_DB_PATH=./data/manual-test.sqlite
+```
+
+随后正常执行命令：
+
+```bash
+pnpm start add \
+  --project test-project \
+  --status active \
+  --summary "测试独立数据库"
+
+pnpm start history --project test-project
+```
+
+项目键必须完全一致：写入 `test-project` 的记录不会出现在 `project-mgr` 的历史中。人类可读的空列表查询会输出 `No entries found.`；使用 `--json` 时则输出 `[]`。
+
+`data/` 已加入 Git ignore，测试数据不会进入版本库。不需要保留时，可以删除 `data/manual-test.sqlite`。
+
+自动化测试会使用内存数据库或系统临时目录中的 SQLite 文件，不会读写默认数据库。`PMGR_DB_PATH=:memory:` 也可用于单条命令，但每个 CLI 命令都是独立进程，命令结束后数据就会消失，不适合连续手工测试。
+
+## 快速开始
+
+追加一条项目状态：
+
+```bash
+pnpm start add \
+  --project project-mgr \
+  --status active \
+  --summary "本地状态账本已可用" \
+  --progress "完成 SQLite 与 CLI" \
+  --next "接入真实项目" \
+  --tag mvp
+```
+
+查询所有项目或单个项目的当前状态：
+
+```bash
+pnpm start current
+pnpm start current --project project-mgr --json
+```
+
+查询历史与指定时间点状态：
+
+```bash
+pnpm start history \
+  --project project-mgr \
+  --since 2026-08-01T00:00:00Z \
+  --limit 20 \
+  --offset 0
+
+pnpm start at \
+  --project project-mgr \
+  --at 2026-08-03T12:00:00+08:00 \
+  --json
+```
+
+## 状态写入
+
+`add` 必须提供：
+
+- `--project`：项目唯一名称，只能使用英文字母、数字、`.`、`_`、`-`，并以字母或数字开头。
+- `--status`：`idea`、`planned`、`active`、`blocked`、`paused`、`completed` 或 `archived`。
+- `--summary`：本次状态摘要。
+
+可选参数：
+
+- `--progress`：已经完成的工作。
+- `--blocker`、`--next`、`--decision`、`--tag`：可以重复传入。
+- `--at`：状态实际发生时间，必须是带时区的 ISO 8601 时间；缺省为当前时间。
+- `--source`：`human`、`agent` 或 `import`；缺省为 `human`。
+- `--external-ref`：全局幂等键。重复写入同一项目时返回原记录；若被其他项目占用则报错。
+- `--json`：输出稳定 JSON。
+
+## 批量导入
+
+`import` 接受一个 JSON 对象、JSON 数组，或每行一个对象的 JSONL 文件。所有记录先校验，再在同一个 SQLite 事务中写入；任一记录失败时整批回滚。
+
+```json
+{
+  "project": "project-mgr",
+  "status": "active",
+  "summary": "核心功能实现完成",
+  "progress": "CLI 与 SQLite 已通过测试",
+  "blockers": [],
+  "nextSteps": ["接入真实项目"],
+  "decisions": ["首版只做本地 CLI"],
+  "tags": ["mvp"],
+  "occurredAt": "2026-08-03T12:00:00+08:00",
+  "source": "human",
+  "externalRef": "project-mgr-2026-08-03-core"
+}
+```
+
+```bash
+pnpm start import statuses.jsonl
+# 等价写法
+pnpm start import --file statuses.jsonl --json
+```
+
+未知字段、未知 CLI 参数、多余位置参数、非法状态和无时区时间都会被拒绝。
+
+## 查询与导出
+
+| 命令      | 用途                       | 主要选项                                                           |
+| --------- | -------------------------- | ------------------------------------------------------------------ |
+| `current` | 所有项目或单项目的当前状态 | `--project`、`--json`                                              |
+| `history` | 单项目历史，最新记录在前   | `--project`、`--since`、`--until`、`--limit`、`--offset`、`--json` |
+| `at`      | 指定时间点及之前的最后状态 | `--project`、`--at`、`--json`                                      |
+| `export`  | 导出全部或单项目记录       | `--project`、`--format json\|jsonl`                                |
+
+全部六个 action 仍可使用 `status <action>` 的兼容形式，例如 `pmgr status export`。人类可读的多条结果按“项目、状态、发生时间、摘要”输出；为空时输出 `No entries found.`。`add`、`import`、`current`、`history`、`at` 支持 `--json`；`export` 由 `--format` 控制格式。
+
+导出内容不包含数据库内部的 `id` 和 `recordedAt`，可以直接重新导入。记录按时间从旧到新导出，从而在恢复时保留相同时间戳记录的先后关系：
+
+```bash
+pnpm start export --format jsonl > project-statuses.jsonl
+
+PMGR_DB_PATH=./data/restored.sqlite \
+  pnpm start import project-statuses.jsonl
+```
+
+## 开发与验证
+
+```bash
+pnpm typecheck
+pnpm lint
+pnpm format-check
+pnpm test
+pnpm coverage
+pnpm build
+```
+
+Statements、branches、functions、lines 的覆盖率门槛均为 100%。详细设计见[架构文档](docs/architecture.md)。

package/dist/cli.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+export declare function run(argv: string[], write?: {
+    (buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
+    (str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
+}): void;

package/dist/cli.js

@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { addStatus, at, current, history, importStatuses, openLedger, parseTime, toPortableStatusEntry, ValidationError, } from "./index.js";
+const repeats = new Set(["next", "blocker", "decision", "tag"]);
+function parse(argv) {
+    const command = [];
+    const flags = Object.create(null);
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (!token.startsWith("--")) {
+            command.push(token);
+            continue;
+        }
+        const key = token.slice(2);
+        if (key === "json") {
+            if (flags[key] !== undefined)
+                throw new ValidationError(`--${key} may only be supplied once`);
+            flags[key] = true;
+            continue;
+        }
+        const value = argv[++index];
+        if (!value || value.startsWith("--"))
+            throw new ValidationError(`--${key} requires a value`);
+        if (repeats.has(key))
+            flags[key] = [...(flags[key] ?? []), value];
+        else if (flags[key] !== undefined)
+            throw new ValidationError(`--${key} may only be supplied once`);
+        else
+            flags[key] = value;
+    }
+    return { command, flags };
+}
+const allowedFlags = new Map([
+    [
+        "add",
+        new Set([
+            "project",
+            "status",
+            "summary",
+            "progress",
+            "blocker",
+            "next",
+            "decision",
+            "tag",
+            "at",
+            "source",
+            "external-ref",
+            "json",
+        ]),
+    ],
+    ["import", new Set(["file", "json"])],
+    ["current", new Set(["project", "json"])],
+    [
+        "history",
+        new Set(["project", "since", "until", "limit", "offset", "json"]),
+    ],
+    ["at", new Set(["project", "at", "json"])],
+    ["export", new Set(["project", "format"])],
+]);
+function validateInvocation(command, flags) {
+    const statusCommand = command[0] === "status";
+    const action = command[statusCommand ? 1 : 0];
+    const allowed = typeof action === "string" ? allowedFlags.get(action) : undefined;
+    if (typeof action !== "string" || !allowed)
+        throw new ValidationError("usage: pmgr <add|import|current|history|at|export> (or: pmgr status <action>)");
+    const positional = command.slice(statusCommand ? 2 : 1);
+    if (action === "import") {
+        if (positional.length > 1)
+            throw new ValidationError("import accepts at most one file argument");
+        if (positional.length === 1 && flags.file !== undefined)
+            throw new ValidationError("import file must be positional or --file, not both");
+    }
+    else if (positional.length) {
+        throw new ValidationError(`${action} does not accept positional arguments`);
+    }
+    for (const key of Object.keys(flags))
+        if (!allowed.has(key))
+            throw new ValidationError(`unknown flag for ${action}: --${key}`);
+    return action;
+}
+function stringFlag(flags, name, required = false) {
+    const value = flags[name];
+    if (required && typeof value !== "string")
+        throw new ValidationError(`--${name} is required`);
+    return typeof value === "string" ? value : undefined;
+}
+function listFlag(flags, name) {
+    return flags[name] ?? [];
+}
+function numberFlag(flags, name, fallback) {
+    const value = stringFlag(flags, name);
+    if (!value)
+        return fallback;
+    const number = Number(value);
+    if (!Number.isInteger(number) || number < 0)
+        throw new ValidationError(`--${name} must be a non-negative integer`);
+    return number;
+}
+function output(value, json, write) {
+    if (json)
+        write(`${JSON.stringify(value)}\n`);
+    else if (Array.isArray(value)) {
+        const rows = value
+            .map((entry) => `${entry.project}\t${entry.status}\t${entry.occurredAt}\t${entry.summary}`)
+            .join("\n");
+        write(`${rows || "No entries found."}\n`);
+    }
+    else
+        write(`${JSON.stringify(value, null, 2)}\n`);
+}
+function imported(file) {
+    if (!file)
+        throw new ValidationError("import file is required");
+    const content = readFileSync(file, "utf8").trim();
+    if (!content)
+        throw new ValidationError(`${basename(file)} is empty`);
+    if (file.endsWith(".jsonl"))
+        return content.split(/\r?\n/).map((line, index) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                throw new ValidationError(`${basename(file)} line ${index + 1} is not JSON`);
+            }
+        });
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        throw new ValidationError(`${basename(file)} is not JSON`);
+    }
+    return Array.isArray(parsed) ? parsed : [parsed];
+}
+export function run(argv, write = process.stdout.write.bind(process.stdout)) {
+    const { command, flags } = parse(argv);
+    const action = validateInvocation(command, flags);
+    const db = openLedger();
+    const json = flags.json === true;
+    try {
+        switch (action) {
+            case "add":
+                output(addStatus(db, {
+                    project: stringFlag(flags, "project", true),
+                    status: stringFlag(flags, "status", true),
+                    summary: stringFlag(flags, "summary", true),
+                    progress: stringFlag(flags, "progress"),
+                    blockers: listFlag(flags, "blocker"),
+                    nextSteps: listFlag(flags, "next"),
+                    decisions: listFlag(flags, "decision"),
+                    tags: listFlag(flags, "tag"),
+                    occurredAt: stringFlag(flags, "at"),
+                    source: stringFlag(flags, "source"),
+                    externalRef: stringFlag(flags, "external-ref"),
+                }).entry, json, write);
+                break;
+            case "import":
+                output(importStatuses(db, imported(stringFlag(flags, "file") ??
+                    command[command[0] === "status" ? 2 : 1] ??
+                    "")).map((result) => result.entry), json, write);
+                break;
+            case "current":
+                output(current(db, stringFlag(flags, "project")), json, write);
+                break;
+            case "history":
+                output(history(db, stringFlag(flags, "project", true), {
+                    since: stringFlag(flags, "since") &&
+                        parseTime(stringFlag(flags, "since"), "since"),
+                    until: stringFlag(flags, "until") &&
+                        parseTime(stringFlag(flags, "until"), "until"),
+                    limit: numberFlag(flags, "limit", 100),
+                    offset: numberFlag(flags, "offset", 0),
+                }), json, write);
+                break;
+            case "at":
+                output(at(db, stringFlag(flags, "project", true), parseTime(stringFlag(flags, "at", true), "at")) ?? null, json, write);
+                break;
+            case "export": {
+                const entries = history(db, stringFlag(flags, "project"), {
+                    limit: -1,
+                })
+                    .reverse()
+                    .map(toPortableStatusEntry);
+                const format = stringFlag(flags, "format") ?? "json";
+                if (format === "jsonl")
+                    write(entries.map((entry) => JSON.stringify(entry)).join("\n") +
+                        (entries.length ? "\n" : ""));
+                else if (format === "json")
+                    output(entries, true, write);
+                else
+                    throw new ValidationError("--format must be json or jsonl");
+                break;
+            }
+        }
+    }
+    finally {
+        db.close();
+    }
+}
+/* c8 ignore start -- process entry glue is covered by the CLI integration tests through run(). */
+if (process.argv[1] &&
+    import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+    try {
+        run(process.argv.slice(2));
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    }
+}
+/* c8 ignore stop */

package/dist/db.d.ts

@@ -0,0 +1,20 @@
+import Database from "better-sqlite3";
+import { type Source, type StatusEntry } from "./domain.js";
+export type Ledger = Database.Database;
+export type InsertResult = {
+    entry: StatusEntry;
+    inserted: boolean;
+};
+export type HistoryOptions = {
+    since?: string;
+    until?: string;
+    limit?: number;
+    offset?: number;
+};
+export declare function databasePath(): string;
+export declare function openLedger(path?: string): Ledger;
+export declare function addStatus(db: Ledger, value: unknown, defaultSource?: Source): InsertResult;
+export declare function importStatuses(db: Ledger, values: unknown[]): InsertResult[];
+export declare function current(db: Ledger, project?: string): StatusEntry[];
+export declare function history(db: Ledger, project?: string, options?: HistoryOptions): StatusEntry[];
+export declare function at(db: Ledger, project: string, occurredAt: string): StatusEntry | undefined;