@openagt/dashboard 0.0.0-stage → 0.8.0

package/LICENSE

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

@@ -1,3 +1,126 @@
-# Temporary Holding Version
+# @openagt/dashboard
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**The Framework** — autonomous AI programming: humans make the important decisions
+while coding agents run unattended.
+
+You register your repos. From then on, agents work on them: each agent gets a throwaway
+checkout of the repo, does its work, and hands the result off as a pull request. Your own
+checkout is never touched.
+
+```bash
+npm i -g @openagt/dashboard
+
+cd ~/code/my-repo
+openagent          # serves the dashboard at http://127.0.0.1:4200
+```
+
+## The CLI is four options and no verbs
+
+```
+openagent              Serve the dashboard in the foreground. Ctrl+C closes it; the
+                       agents it started go on to their own end.
+
+  --port <n>           Dashboard port (default: 4200).
+  --host <addr>        Bind address (default: 127.0.0.1). A non-loopback address
+                       exposes the dashboard to your network and generates a shared
+                       token; the printed URL carries it, and any request without it
+                       gets 401. Exposing the daemon to the network is a security
+                       decision.
+  -h, --help           Show this help.
+  -v, --version        Print the version.
+```
+
+Everything else is the dashboard. It is the product's user interface, and where an agent's
+prompt, its coding agent and its model are chosen. There is no option that begins an agent:
+the command cannot start one at all.
+
+## How it works
+
+The Framework runs no coding agent and makes no model call. Starting an agent is running
+**one shell line the project itself names** — its `start` hook, in the project's own
+`.the-framework/hooks.yml`:
+
+```yaml
+start: agent-runner run --detach "$PROMPT" ${DRIVER:+--driver "$DRIVER"} ${MODEL:+--model "$MODEL"} ${THEN:+--then "$THEN"} ${PUBLISH:+--publish "$PUBLISH"} ${BASE:+--base "$BASE"}
+resume: agent-runner run --detach --resume "$RUN_ID" ${TEXT:+"$TEXT"} ${ANSWER:+--answer "$ANSWER"}
+check: agent-runner check ${DRIVER:+--driver "$DRIVER"}
+```
+
+The line is given the prompt and the user's picks in its environment, and answers one JSON
+document whose `id` names the agent it began. From there the agent belongs to whatever that
+line started. Adding a project writes these three lines into the file, so a new project, an
+empty folder included, starts an agent with nothing typed by hand. They are a default: a line
+already there is kept, and any of them can be changed or deleted. A line finds its tools in the
+project's installed packages first, then in the dashboard's built-in ones, which bring `agent-runner`;
+nothing is downloaded to run a line. A project with no `start` line cannot start an agent from
+the dashboard, and the dashboard says so. `npx agent-scheduler init`, run in the project, writes
+the scheduler's `open` and `close` lines (they start it when the dashboard opens and stop it
+when it closes), keeping any line already there. The file's keys are `open`, `close`, `start`, `resume` and `check`; any other key
+is refused and the whole file ignored.
+
+The launcher's **Post-merge cleanup** box, shown where the project has the
+`post-merge-cleanup` command, puts `/post-merge-cleanup` in `THEN`: once the agent ends done
+with a pull request, agent-runner starts a fresh agent on its branch with that command and the
+first agent's id, and holds the pull request's merge until that one is done. Its default is
+Settings → Agent → Post-merge cleanup, which the box writes too.
+
+The launcher's chip above the box says which branch the agent starts from: the project's
+main branch, fetched first, or **My local branch**, the branch the project's folder is on,
+with its commits that are not pushed (edits that are not committed are not carried). The
+local pick puts the branch's name in `BASE`, and is saved per project. The chip is shown only
+when the `start` line mentions `$BASE`: a project whose line was written before the chip
+existed gets it by adding `${BASE:+--base "$BASE"}` to the line.
+
+The `check` line is what the launcher runs before a Start, with the picked coding agent in
+`DRIVER`: it answers one JSON document with `problems` (a coding agent not installed or logged
+out: said in red) and `warnings` (said in amber), each line naming its own fix. A project
+with no `check` line shows nothing there.
+
+A package's own settings are no hook. The scheduler's (how far past the quota boundary it may
+start unattended work, a switch and a publish pick per scheduled command) are the scheduler
+package's own Settings section and Overview card, and the handle on the usage bar is its stop
+line: its part of the dashboard reads them with `agent-scheduler status` and saves them with
+`agent-scheduler offset`, `switch` and `publish`.
+
+The dashboard is a **projection of the agent's own files**. The agent's tool keeps the
+agent's card (`<id>.json`) and diary (`<id>.jsonl`) under `.the-framework/` in the agent's
+checkout, and copies both onto the project's `agent-data` branch when the agent ends.
+Everything the dashboard shows — live, and months later — it reads from those two files.
+
+Steering goes back the same way, never over a channel:
+
+- **What you say to a working agent** becomes a line in its `inbox.jsonl`, which the agent's
+  tool reads when a turn ends.
+- **What you say to an agent that has ended** — your words, or your answer to the question it
+  stopped on — runs the project's `resume` hook, which continues that same agent.
+- **Stop** is a signal to the process the agent's card names.
+
+So a working agent and a finished one render identically, and an agent on another machine
+needs only its lines carried home.
+
+- **One daemon per machine.** Running the CLI in any registered repo finds it. It serves
+  the dashboard, runs each project's hooks, and runs the background work — the notifications
+  and the cloud sweeps.
+- **An agent is one task being worked**, in its own checkout on its own branch. You can watch
+  it, answer its questions, and say more to it — or not be there at all.
+- **What you can ask for is your project's own commands**: its skills, read from
+  `.claude/skills/` and `.agents/skills/`, plus free text and the prompts you save. The
+  Framework ships no prompt text.
+- **Work leaves as a pull request**, opened by the agent itself. An agent that committed
+  nothing publishes nothing.
+
+## Layout
+
+- `src/` — the CLI, the daemon, the hooks, the reading of a project's agents, and the server
+  side of the dashboard. Node only.
+- `dashboard/` — the browser app: a Vite SPA the daemon serves as static files,
+  talking back over plain HTTP. See [its README](./dashboard/README.md).
+
+A `LOGIC.md` sits beside every source file and directory, describing the business
+logic it implements, in prose written to be read instead of the code.
+[`LOGIC.md`](./LOGIC.md) at the package root is the place to start.
+
+## Status
+
+Pre-release, published from the `0.x` line. There are no users to keep compatible,
+so the code prefers being clean over being backward-compatible.

package/dist/agent-archive.d.ts

@@ -0,0 +1,35 @@
+import { ARCHIVE_DIR } from './store/index.js';
+import { type GitRunner } from '@gemstack/agent-data';
+/**
+ * Committed session history (#1179): where a project's finished agents are archived so they survive
+ * the repo being cleaned.
+ *
+ * The bug this exists for: agent state was written to `.the-framework/agents/`, which the install-time
+ * `.gitignore` keeps untracked, so `git clean -fdx` — an ordinary thing to do to a repo — deleted
+ * every session a project had ever run. Nothing was recoverable, because nothing had ever been
+ * committed. Since #1582 the lasting copy lives on the `agents-logs` branch (#1748), as `agents/<user>/`.
+ *
+ * Scoped per user rather than one shared directory. Two people working the same repo would
+ * otherwise write the same paths from different machines and conflict on every merge; under their
+ * own directory their histories simply sit side by side. The list being visible to the whole team
+ * is the intended outcome, not a leak — see the issue.
+ *
+ * The identity is the git `user.email` already configured in the repo, so there is nothing new to
+ * set up and the directory matches the name on the commits.
+ */
+/** The directory, under a user's own directory, that holds their archived agents. */
+export { ARCHIVE_DIR };
+/** Where an agent's history goes when git has no identity configured. */
+export declare const ANONYMOUS_USER_DIR = "anonymous";
+/**
+ * An email as a directory name: lowercased, with anything outside a conservative set replaced by
+ * `-`. The result must start with a letter or digit, which is what rules out `.`, `..` and dotfile
+ * names — this value comes from repo configuration and is joined onto a path, so a name that could
+ * climb out of the directory is the one thing that must be impossible. Anything that cannot be made
+ * to fit falls back to {@link ANONYMOUS_USER_DIR} rather than to a guess.
+ */
+export declare function userDirName(email: string | undefined): string;
+export declare function resolveUserDir(cwd: string, git?: GitRunner): Promise<string>;
+/** Drop the {@link resolveUserDir} cache. For tests, and for a daemon that outlives a config change. */
+export declare function forgetUserDirs(): void;
+//# sourceMappingURL=agent-archive.d.ts.map

package/dist/agent-archive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-archive.d.ts","sourceRoot":"","sources":["../src/agent-archive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAA;AACpE;;;;;;;;;;;;;;;;GAgBG;AAEH,qFAAqF;AACrF,OAAO,EAAE,WAAW,EAAE,CAAA;AAEtB,yEAAyE;AACzE,eAAO,MAAM,kBAAkB,cAAc,CAAA;AAQ7C;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAQ7D;AAYD,wBAAsB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,GAAE,SAA2B,GAAG,OAAO,CAAC,MAAM,CAAC,CAOnG;AAED,wGAAwG;AACxG,wBAAgB,cAAc,IAAI,IAAI,CAErC"}

package/dist/agent-archive.js

@@ -0,0 +1,67 @@
+import { ARCHIVE_DIR } from './store/index.js';
+import { nodeGitRunner } from '@gemstack/agent-data';
+/**
+ * Committed session history (#1179): where a project's finished agents are archived so they survive
+ * the repo being cleaned.
+ *
+ * The bug this exists for: agent state was written to `.the-framework/agents/`, which the install-time
+ * `.gitignore` keeps untracked, so `git clean -fdx` — an ordinary thing to do to a repo — deleted
+ * every session a project had ever run. Nothing was recoverable, because nothing had ever been
+ * committed. Since #1582 the lasting copy lives on the `agents-logs` branch (#1748), as `agents/<user>/`.
+ *
+ * Scoped per user rather than one shared directory. Two people working the same repo would
+ * otherwise write the same paths from different machines and conflict on every merge; under their
+ * own directory their histories simply sit side by side. The list being visible to the whole team
+ * is the intended outcome, not a leak — see the issue.
+ *
+ * The identity is the git `user.email` already configured in the repo, so there is nothing new to
+ * set up and the directory matches the name on the commits.
+ */
+/** The directory, under a user's own directory, that holds their archived agents. */
+export { ARCHIVE_DIR };
+/** Where an agent's history goes when git has no identity configured. */
+export const ANONYMOUS_USER_DIR = 'anonymous';
+/**
+ * Longest directory name we will make from an email. Well past any real address, and short enough
+ * that the archive paths under it stay inside the path limits of every platform we run on.
+ */
+const MAX_USER_DIR = 64;
+/**
+ * An email as a directory name: lowercased, with anything outside a conservative set replaced by
+ * `-`. The result must start with a letter or digit, which is what rules out `.`, `..` and dotfile
+ * names — this value comes from repo configuration and is joined onto a path, so a name that could
+ * climb out of the directory is the one thing that must be impossible. Anything that cannot be made
+ * to fit falls back to {@link ANONYMOUS_USER_DIR} rather than to a guess.
+ */
+export function userDirName(email) {
+    const cleaned = (email ?? '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9@._+-]/g, '-');
+    return cleaned.length > 0 && cleaned.length <= MAX_USER_DIR && /^[a-z0-9][a-z0-9@._+-]*$/.test(cleaned)
+        ? cleaned
+        : ANONYMOUS_USER_DIR;
+}
+/**
+ * The directory name for the identity this repo commits under, from `git config user.email`.
+ *
+ * Cached per repo for the process's life: it is read on every archive, it changes about as often
+ * as a git identity does, and an agent that outlived a config change would only mean the next agent
+ * files itself correctly. A missing or unreadable identity yields {@link ANONYMOUS_USER_DIR}, so
+ * history is still kept — filing it under a placeholder is strictly better than dropping it.
+ */
+const cache = new Map();
+export async function resolveUserDir(cwd, git = nodeGitRunner()) {
+    const hit = cache.get(cwd);
+    if (hit !== undefined)
+        return hit;
+    const email = await git(['config', 'user.email'], cwd).catch(() => '');
+    const dir = userDirName(email.trim());
+    cache.set(cwd, dir);
+    return dir;
+}
+/** Drop the {@link resolveUserDir} cache. For tests, and for a daemon that outlives a config change. */
+export function forgetUserDirs() {
+    cache.clear();
+}
+//# sourceMappingURL=agent-archive.js.map

package/dist/agent-archive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-archive.js","sourceRoot":"","sources":["../src/agent-archive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,aAAa,EAAkB,MAAM,sBAAsB,CAAA;AACpE;;;;;;;;;;;;;;;;GAgBG;AAEH,qFAAqF;AACrF,OAAO,EAAE,WAAW,EAAE,CAAA;AAEtB,yEAAyE;AACzE,MAAM,CAAC,MAAM,kBAAkB,GAAG,WAAW,CAAA;AAE7C;;;GAGG;AACH,MAAM,YAAY,GAAG,EAAE,CAAA;AAEvB;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAAC,KAAyB;IACnD,MAAM,OAAO,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC;SAC1B,IAAI,EAAE;SACN,WAAW,EAAE;SACb,OAAO,CAAC,iBAAiB,EAAE,GAAG,CAAC,CAAA;IAClC,OAAO,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,OAAO,CAAC,MAAM,IAAI,YAAY,IAAI,0BAA0B,CAAC,IAAI,CAAC,OAAO,CAAC;QACrG,CAAC,CAAC,OAAO;QACT,CAAC,CAAC,kBAAkB,CAAA;AACxB,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,KAAK,GAAG,IAAI,GAAG,EAAkB,CAAA;AAEvC,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,GAAW,EAAE,GAAG,GAAc,aAAa,EAAE;IAChF,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;IAC1B,IAAI,GAAG,KAAK,SAAS;QAAE,OAAO,GAAG,CAAA;IACjC,MAAM,KAAK,GAAG,MAAM,GAAG,CAAC,CAAC,QAAQ,EAAE,YAAY,CAAC,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAA;IACtE,MAAM,GAAG,GAAG,WAAW,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAA;IACrC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;IACnB,OAAO,GAAG,CAAA;AACZ,CAAC;AAED,wGAAwG;AACxG,MAAM,UAAU,cAAc;IAC5B,KAAK,CAAC,KAAK,EAAE,CAAA;AACf,CAAC"}

package/dist/agent-commit.d.ts

@@ -0,0 +1,140 @@
+import type { ProjectSummary } from './dashboard/projects.js';
+import type { GitRunner } from './project.js';
+/**
+ * Committing the agent archives the daemon writes (#912/#1179) into the project checkout.
+ *
+ * An agent's own worktree sweeps its archive on teardown (`store/worktree.ts`). The main checkout has
+ * no such path — `install.ts` commits once at activation and nothing after — so an archive written
+ * there sat as a working-tree change until a human happened to commit it. That is the gap between
+ * "the history is in Git" and "the history reaches Git by itself".
+ *
+ * It used to carry a second pathspec, the per-agent conversation markdown, and the machinery for
+ * choosing between them: a pathspec matching no file aborts the whole `git add`, so every project
+ * that had sessions but had never recorded a chat needed the other pattern dropped. With one
+ * record (B3) there is one pathspec and nothing to choose.
+ *
+ * Two rules shape the whole module, both about writing into a repo somebody else is using.
+ *
+ * Path-scoped, never `git add -A`. The pathspec names the archives and nothing else, the way
+ * `queue-promote.ts` names the queue file, so whatever the user has in progress cannot ride along
+ * in our commit. A pathspec commit also leaves their index alone: what they had staged is still
+ * staged afterwards.
+ *
+ * Debounced on an idle window rather than committed per write. Archives land seconds apart, and a
+ * commit each would bury the project's real history under noise. A poll that sees the same pending
+ * set twice running treats it as settled and commits the batch; a burst keeps resetting it.
+ * {@link AgentCommitterOptions.maxWaitMs} caps that, so a project that never goes idle still
+ * lands instead of being starved forever.
+ *
+ * Tolerates not being alone (the question (#605) this waited on). One daemon per machine is the rule
+ * today (#393), but the committer never assumes it: a locked index or a rebase/merge in progress
+ * means somebody else is mid-operation, so it skips rather than commits into their work, and a
+ * failed commit is swallowed and retried on the next window.
+ */
+/**
+ * The committed agent archives (#1179), under every user's own directory.
+ *
+ * `:(glob)` magic so the `*` stops at a path separator — a plain pathspec wildcard matches `/` too,
+ * and would reach further down `.the-framework/` than this means to.
+ *
+ * The trailing `/**` is load-bearing, and its absence is silent: glob magic matches the pattern
+ * against each file's whole path rather than treating a directory as a prefix, so
+ * `.the-framework/*​/sessions` matches no *file* and `git add` fails with "did not match any files"
+ * — a committer that commits nothing, every time. Only a real repo shows this.
+ */
+export declare const ARCHIVE_PATHSPEC = ":(glob).the-framework/*/agents/**";
+/** How long writes may keep arriving before the batch is committed anyway. */
+export declare const COMMIT_MAX_WAIT_MS: number;
+/** What one attempt did, or why it did nothing. */
+export type CommitOutcome = {
+    committed: true;
+    files: string[];
+} | {
+    committed: false;
+    reason: string;
+};
+/** Whether a path exists. Injectable so the busy check is testable without real lock files. */
+export type PathProbe = (path: string) => Promise<boolean>;
+/** A {@link PathProbe} over `fs.access`. */
+export declare function nodePathProbe(): PathProbe;
+/**
+ * The commit message a batch writes. Names what moved, so the log line stands alone.
+ *
+ * Counted by run, not by file: one archived agent is a `<id>.json` and a `<id>.jsonl`, and
+ * "2 sessions" for a single session would be a lie told by the batch's own commit message.
+ */
+export declare function commitMessage(files: string[]): string;
+/**
+ * The archive files with uncommitted changes, as repo-relative paths, sorted so the result is
+ * a stable fingerprint the debounce can compare across polls.
+ *
+ * `--porcelain` v1 is parsed rather than `--short` because its two status columns are fixed-width
+ * and its paths are quoted consistently. A rename (`R  old -> new`) reports the destination, which
+ * is the path we would commit. Anything unreadable — not a repo, no git — reads as no changes.
+ *
+ * `-uall` is load-bearing, not a detail. By default git collapses a wholly-untracked directory into
+ * one entry instead of naming the files under it, which makes the fingerprint identical whether one
+ * archive is being written or ten. The debounce compares fingerprints, so without this the idle
+ * window could never see a burst and would commit straight through the middle of one. Only a real
+ * repo shows this; a per-file fake does not.
+ */
+export declare function pendingAgents(cwd: string, git?: GitRunner): Promise<string[]>;
+/**
+ * Why the repo is in no state to be committed into, or `undefined` when it is fine.
+ *
+ * The git dir is resolved through git rather than assumed to be `<cwd>/.git`, so this is right in a
+ * linked worktree, where `.git` is a file pointing elsewhere and the markers live in the real dir.
+ */
+export declare function gitBusy(cwd: string, git?: GitRunner, exists?: PathProbe): Promise<string | undefined>;
+/**
+ * Stage and commit the pending agent archives under `cwd`, scoped to {@link ARCHIVE_PATHSPEC}.
+ *
+ * `add` before `commit` because a brand-new archive is untracked, and `git commit -- <path>` only
+ * knows paths git already knows. Both are pathspec-scoped, so the staging is as narrow as the
+ * commit and the user's own staged work is neither swept in nor disturbed. Nothing pending returns
+ * early: a pathspec matching no file is a hard error to git, and "no session has been archived here
+ * yet" is not an error at all.
+ *
+ * Never throws: this runs on a background tick with nothing to catch it.
+ */
+export declare function commitAgents(cwd: string, git?: GitRunner, exists?: PathProbe): Promise<CommitOutcome>;
+/** A running committer; call {@link AgentCommitter.stop} to end it. */
+export interface AgentCommitter {
+    stop: () => void;
+    /** Run one poll now. Exposed so the daemon and tests can drive it deterministically. */
+    poll: () => Promise<void>;
+    /**
+     * Commit every project's pending agent archives now, skipping the idle window. For shutdown: the
+     * daemon is going away, so waiting for quiet would just defer the work to the next boot. Returns
+     * how many projects committed.
+     */
+    flush: () => Promise<number>;
+}
+/** Options for {@link startAgentCommitter}. */
+export interface AgentCommitterOptions {
+    /** The projects to sweep each poll (the daemon passes the registry, mapped to summaries). */
+    projects: () => Promise<ProjectSummary[]>;
+    /** Commit anyway once a project has been pending this long, ms. Default {@link COMMIT_MAX_WAIT_MS}. */
+    maxWaitMs?: number;
+    /** Injectable git (tests). */
+    git?: GitRunner;
+    /** Injectable existence probe for the busy check (tests). */
+    exists?: PathProbe;
+    /** Clock, injectable for the max-wait cap (tests). */
+    now?: () => number;
+    /** Where a committed batch is announced. */
+    log?: (message: string) => void;
+}
+/**
+ * Start committing settled agent archives, and return the handle that stops it.
+ *
+ * The idle window is the poll itself: a project whose pending set is byte-identical to the previous
+ * poll's has stopped being written to, so its batch is committed. Anything still moving is recorded
+ * and reconsidered next time, unless it has been dirty past `maxWaitMs`, which forces it through.
+ *
+ * Forgiving throughout — a failed project scan, a busy repo or a rejected commit costs one window
+ * and is retried, never a throw. Owns no timer (E4): the daemon's one clock calls {@link
+ * AgentCommitter.poll}, and the window it debounces on is that cadence.
+ */
+export declare function startAgentCommitter(opts: AgentCommitterOptions): AgentCommitter;
+//# sourceMappingURL=agent-commit.d.ts.map

package/dist/agent-commit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-commit.d.ts","sourceRoot":"","sources":["../src/agent-commit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAG7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAI7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,sCAAoD,CAAA;AAEjF,8EAA8E;AAC9E,eAAO,MAAM,kBAAkB,QAAa,CAAA;AAE5C,mDAAmD;AACnD,MAAM,MAAM,aAAa,GACrB;IAAE,SAAS,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GACpC;IAAE,SAAS,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAExC,+FAA+F;AAC/F,MAAM,MAAM,SAAS,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAE1D,4CAA4C;AAC5C,wBAAgB,aAAa,IAAI,SAAS,CAQzC;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAGrD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,GAAE,SAA2B,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAWpG;AA0BD;;;;;GAKG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,MAAM,EACX,GAAG,GAAE,SAA2B,EAChC,MAAM,GAAE,SAA2B,GAClC,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAU7B;AAKD;;;;;;;;;;GAUG;AACH,wBAAsB,YAAY,CAChC,GAAG,EAAE,MAAM,EACX,GAAG,GAAE,SAA2B,EAChC,MAAM,GAAE,SAA2B,GAClC,OAAO,CAAC,aAAa,CAAC,CAcxB;AAED,uEAAuE;AACvE,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,IAAI,CAAA;IAChB,wFAAwF;IACxF,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IACzB;;;;OAIG;IACH,KAAK,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;CAC7B;AAED,+CAA+C;AAC/C,MAAM,WAAW,qBAAqB;IACpC,6FAA6F;IAC7F,QAAQ,EAAE,MAAM,OAAO,CAAC,cAAc,EAAE,CAAC,CAAA;IACzC,uGAAuG;IACvG,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,8BAA8B;IAC9B,GAAG,CAAC,EAAE,SAAS,CAAA;IACf,6DAA6D;IAC7D,MAAM,CAAC,EAAE,SAAS,CAAA;IAClB,sDAAsD;IACtD,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;IAClB,4CAA4C;IAC5C,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAChC;AAeD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,qBAAqB,GAAG,cAAc,CA4E/E"}