@duetso/agent 0.1.20

package/LICENSE

@@ -0,0 +1,189 @@
+                                 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.
+
+      "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 Duet
+
+   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.

package/README.md

@@ -0,0 +1,315 @@
+# duet-agent
+
+An opinionated, full-stack agent turn runner. Native memories. Native interrupts. Multi-agent by default.
+
+**No MCP. Everything is files and CLI.**
+
+## Why another agent framework?
+
+Existing agent turn runners treat tools and memories as pluggable modules. This makes them flexible but fundamentally disconnected — memory is an afterthought.
+
+duet-agent takes the opposite approach: **memory is woven into the core architecture.** An agent without memory is stateless. Interrupts are handled by the underlying pi agent runtime, so the turn runner does not need its own interrupt bus.
+
+## Architecture
+
+The diagram below walks through a realistic agent-routed state machine: outbound conference
+outreach. The user prompt enters the `TurnRunner`, the runner agent picks the next state based on
+prompt, history, and available state definitions, and the state machine drives the business process
+until it hits a terminal state. The same definition can start in the middle — for example, the
+runner can skip straight to `wait_for_reply` if the user says “I already emailed them”.
+
+```mermaid
+stateDiagram-v2
+  direction TB
+
+  [*] --> Classify : user prompt
+  Classify --> AgentMode : one-off task
+  Classify --> Outreach : matches a state machine
+
+  AgentMode --> [*] : answer / edits
+
+  state Outreach {
+    direction TB
+    [*] --> research_prospect
+
+    research_prospect : research_prospect (agent)\nweb + notes lookup
+    draft_email       : draft_email (agent)\nwrite first-touch email
+    send_email        : send_email (script)\nbash: gmail send
+    wait_for_reply    : wait_for_reply (poll)\nevery 6h: check inbox
+    schedule_meeting  : schedule_meeting (script)\nbash: calendly create
+    meeting_booked    : meeting_booked (terminal: completed)
+    not_interested    : not_interested (terminal: completed)
+    no_response       : no_response (terminal: cancelled)
+
+    research_prospect --> draft_email     : enough signal
+    research_prospect --> not_interested  : disqualified
+    draft_email       --> send_email
+    send_email        --> wait_for_reply
+    wait_for_reply    --> schedule_meeting : positive reply
+    wait_for_reply    --> not_interested   : declined
+    wait_for_reply    --> no_response      : 14d timeout
+    schedule_meeting  --> meeting_booked
+  }
+
+  Outreach --> [*]
+```
+
+Each state is one of the four kinds the runner understands:
+
+- **agent** states run a sub-agent with a prompt, optional system prompt, and optional skill allowlist.
+- **script** states shell out (`bash`, `curl`, CLIs) for anything with an API.
+- **poll** states wait on an external signal by running one script check per interval, or by using a timer poll for pure delays.
+- **terminal** states record a business outcome (`completed`, `cancelled`, `failed`).
+
+Observational memory, pi coding tools, and guardrails sit underneath every state transition; they
+are not states themselves.
+
+## Key Differentiators
+
+### Native Memory
+
+Memory is first-class. The default `MemoryStore` is in-memory and emits observation events; optional PGlite storage hydrates and persists durable observations outside the turn runner session.
+
+The memory model follows observational memory: turn runner session messages are observed into durable text observations, and a reflector condenses observations when they grow too large. Observations are scoped as `session` or `resource`.
+
+### Pi Coding Tools
+
+Sub-agents use the default tools from `@earendil-works/pi-coding-agent`: read, bash, edit, and write. The turn runner supplies a working directory and can restrict which skills are injected into a state-machine agent state; it does not wrap those tools in a second sandbox abstraction.
+
+### Native Interrupts
+
+Interrupt behavior comes from the underlying pi agent runtime. A user can send a message while a pi session is running, and the runtime can handle it as an interruption or as a follow-up. duet-agent does not add a second interrupt bus on top.
+
+### Multi-Agent by Default
+
+The turn runner can delegate durable process steps into agent states. Agent states are not pre-built classes; they are state-machine states with prompts, optional system prompts, and optional skill allowlists.
+
+### Three Execution Modes
+
+The turn runner has three top-level modes:
+
+- `agent`: handle the prompt as a normal agent session. This is for one-off tasks, coding requests, reviews, research, and anything that can complete in the current session.
+- `state_machine`: route the prompt into an agent-routed state machine. This is for long-running business processes with durable state, waits, and terminal business outcomes.
+- `auto`: let the turn runner classify the prompt and choose either `agent` or `state_machine`.
+
+Normal agent mode handles immediate work; state-machine mode handles business processes that may pause, resume, wait on external systems, or start in the middle based on the user's prompt. In `auto`, the runner classifies the prompt and routes to whichever fits.
+
+### Agent-Routed State Machines
+
+duet-agent is exploring long-running agent-routed state machines for business processes like outbound sales, conference outreach, and development loops. The design goal is **not** to become a workflow engine like Temporal, Airflow, or GitHub Actions.
+
+Instead, state machines are agent-routed. A state-machine definition describes the available business states: agent states, shell-script states, poll states, and terminal states. The runner keeps the state-machine system prompt cache-friendly by including only stable routing instructions plus the original prompt and available state definitions. Current state and history stay in the parent agent conversation, where state transitions, script results, poll results, and user follow-ups are already recorded.
+
+The state machine is higher level than task execution. It tracks one current business state at a time. If a state needs fan-out, parallelism, or a task-level workflow, that belongs inside an agent or script state. The agent can execute a complex workflow internally; the state machine only records the business transition before and after that state.
+
+This keeps state machines flexible enough to start in the middle. For example, a user can say: "prospect person X, I've already sent email, just wait for response." The same outreach state machine can skip research and email sending, then choose the wait-for-response state because the runner agent understands the existing context.
+
+External integrations stay simple: anything with an API or CLI is a script state or script poll. Timer polls cover pure delays such as "wait before retry." Email, GitHub, Calendly, CRM systems, and webhooks do not need first-class engine concepts. If the state machine can tolerate a few minutes of polling delay, a bash script is enough.
+
+What this is not:
+
+- Not a deterministic DAG scheduler.
+- Not a low-level durable execution runtime.
+- Not a workflow service with queues, workers, locks, and retries as the main abstraction.
+- Not a replacement for infrastructure workflow engines when exact-once execution or strict SLAs matter.
+
+The turn runner should provide enough structure for an agent to make good process decisions, while leaving hard operational guarantees to external systems.
+
+### Optional Guardrails
+
+Pattern-based (fast, regex) and semantic (LLM-evaluated) guardrails compose into a firewall. Every bash command and file write can be checked before execution.
+
+## CLI Install
+
+The CLI runs on Bun because OpenTUI is Bun-native. Install Bun first if it is not already available:
+
+```bash
+curl -fsSL https://bun.sh/install | bash
+```
+
+Install the CLI globally to make the `duet` command available on your PATH:
+
+```bash
+bun add --global @duetso/agent
+```
+
+You can also install it globally with another package manager:
+
+```bash
+npm install --global @duetso/agent
+pnpm add --global @duetso/agent
+yarn global add @duetso/agent
+```
+
+Upgrade an existing global installation:
+
+```bash
+duet upgrade
+```
+
+## SDK Install
+
+Install the package as a dependency when you want to use the turn runner from TypeScript or JavaScript:
+
+```bash
+npm install @duetso/agent
+```
+
+## Development
+
+This repo uses Bun for package management, Husky for pre-commit checks, and Docker for functional tests.
+
+```bash
+bun install
+bun run setup  # install/start Docker on macOS or Linux if needed
+bun run check-types
+bun run lint
+bun run eval   # runs live evals inside Docker
+bun run test   # runs the test suite inside Docker
+```
+
+Use `bun run test` and `bun run eval`, not raw `bun test`, as the source of truth. File-writing tests and evals run in Docker so focused host runs cannot create `.duet`, PGlite databases, or home-directory skill fixtures in the checkout.
+
+The pre-commit hook runs `format`, `check-types`, and `lint`.
+
+## CLI Quick Start
+
+Set a provider API key in the environment or in `<workdir>/.env`, then run `duet` from any project directory. When `--model` is omitted, the CLI infers a default from the configured provider: Anthropic, AI Gateway, and OpenRouter use Opus 4.7; OpenAI uses GPT-5.5.
+
+```bash
+export ANTHROPIC_API_KEY=sk-...
+
+# Start a session
+duet "build a REST API with Express"
+
+# Open an interactive session without an initial prompt
+duet
+
+# With options
+duet -m anthropic:claude-opus-4-7 --workdir ./my-project "refactor the auth module"
+
+# With a custom observational memory model
+duet --memory-model anthropic:claude-sonnet-4-6 "summarize this repo"
+
+# With additional system instructions
+duet --system-prompt "Prefer concise answers." "review this repo"
+
+# Override the default AGENTS.md system prompt file
+duet --system-prompt-file TEAM.md "review this repo"
+
+# Disable system prompt file loading
+duet --no-system-prompt-files "review this repo"
+
+# Resume a saved session
+duet --resume session_abc123 --workdir ./my-project
+
+# Through Vercel AI Gateway
+export AI_GATEWAY_API_KEY=...
+duet -m vercel-ai-gateway:anthropic/claude-opus-4.7 "review this repo"
+```
+
+For local development from a checkout, use the package script:
+
+```bash
+bun run cli -- "build a REST API with Express"
+```
+
+## SDK Quick Start
+
+```typescript
+import { TurnRunner } from "@duetso/agent";
+
+const turnRunner = new TurnRunner({
+  model: "anthropic:claude-opus-4-7",
+  cwd: process.cwd(),
+  mode: "auto",
+});
+
+const terminal = await turnRunner.turn({
+  type: "start",
+  prompt: "Build a todo app with React and TypeScript",
+});
+```
+
+`TurnRunner.turn()` is the concurrency boundary. Callers may call it repeatedly
+while work is active; the runner folds active `prompt` and `answer` commands
+back into the active pi agent as `steer` or `follow_up`, queues wakes and other
+work it cannot absorb immediately, and emits one terminal event when the whole
+active work chain is done. The parent runner transcript stays linear: state
+machine continuations, script results, poll results, and user follow-ups rejoin
+the parent agent rather than creating separate conversation branches.
+
+## Memory And Persistence
+
+duet-agent owns a concrete event-emitting `MemoryStore` internally. It is the runtime state container, not a database adapter.
+
+`SessionManager` stores session snapshots under `~/.duet/sessions` by default and enables durable observational memory at `~/.duet/memory.db`. Pass `memoryDbPath: false` to keep observational memory in process only, or provide `memoryDbPath` for a custom database location.
+
+```typescript
+import { SessionManager } from "@duetso/agent";
+
+const manager = new SessionManager({
+  model: "anthropic:claude-opus-4-7",
+});
+```
+
+The memory module hydrates durable observations from an embedded Postgres database powered by PGlite before the first turn and writes observation updates back as memory changes. Raw conversation messages stay in `TurnState.agent.messages`; memory persistence stores only derived observations/reflections.
+
+You can also resume directly from saved state:
+
+```typescript
+const terminal = await turnRunner.turn({
+  type: "prompt",
+  state: savedState,
+  message: "Continue the previous goal",
+  behavior: "follow_up",
+});
+```
+
+Resume continues turn runner session state, not an in-flight model/tool call. Any `in_progress` todo is retried from `pending`.
+
+Observational memory is enabled by default with thresholds tuned for modern 200k-token model windows:
+
+- Raw messages are observed around `150_000` tokens so exact transcript context and prompt caching are used before compaction.
+- Observation logs are reflected around `90_000` tokens, targeting about `65_000` tokens after reflection.
+- Raw-tail retention keeps about `40_000` exact message tokens after observation activation.
+- Observation context is injected as reminder messages; replacing raw context with observations/reflections is the compaction path.
+
+## Skills
+
+Skills are loaded from `<cwd>/.duet/skills`, `<cwd>/.agents/skills`, `~/.duet/skills`, and `~/.agents/skills` by default, using `@earendil-works/pi-coding-agent`'s skill loader. The turn runner injects every loaded skill's description and instructions into the agent system prompt. `getSkills()` returns the discovered skills, including YAML frontmatter descriptions such as block scalars.
+
+## Guardrails
+
+The turn runner installs its default safety checks internally. Add extra guardrail config objects when a deployment needs stricter local policy.
+
+```typescript
+const turnRunner = new TurnRunner({
+  // ...
+  guardrails: [
+    {
+      kind: "pattern",
+      rules: [
+        { pattern: /production-db/i, action: "warn", reason: "Production database mentioned" },
+      ],
+    },
+    {
+      kind: "semantic",
+      model: getModel("anthropic", "claude-haiku-4-5"),
+      policy: "Never delete production data. Never expose secrets in output.",
+    },
+  ],
+});
+```
+
+## Design Principles
+
+1. **Files and CLI over protocols.** No MCP, no custom APIs. If you can't do it with bash, you can't do it.
+2. **Runtime state over persistence.** The turn runner owns in-memory state and emits events. Persistence lives in external modules or initial-state hydration.
+3. **Agent-routed state machines over workflow engines.** Long-running state machines describe available business states; a runner agent decides what to do next from prompt, state, and history. Task-level workflows belong inside agent or script states.
+4. **Dynamic over static.** Agent states are defined by state machines at runtime, not pre-built classes.
+5. **Simple over flexible.** Default pi coding tools. One default memory store. Constraints breed creativity.
+
+## License
+
+Apache-2.0

package/dist/package.json

@@ -0,0 +1,84 @@
+{
+    "name": "@duetso/agent",
+    "version": "0.1.20",
+    "description": "An opinionated full-stack agent turn runner with native memories, interrupts, and multi-agent orchestration",
+    "keywords": [
+        "agent",
+        "ai",
+        "llm",
+        "memory",
+        "multi-agent",
+        "session-manager"
+    ],
+    "license": "Apache-2.0",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/dzhng/duet-agent"
+    },
+    "bin": {
+        "duet": "dist/src/cli.js"
+    },
+    "files": [
+        "dist/package.json",
+        "dist/src",
+        "LICENSE",
+        "README.md"
+    ],
+    "type": "module",
+    "main": "dist/src/index.js",
+    "types": "dist/src/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/src/index.d.ts",
+            "import": "./dist/src/index.js"
+        },
+        "./package.json": "./package.json"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "setup": "bash scripts/setup-docker.sh",
+        "build": "tsc",
+        "check-types": "tsc --noEmit",
+        "cli": "bun src/cli.ts",
+        "dev": "tsc --watch",
+        "eval": "docker run --rm -v \"$PWD:/src:ro\" -w /work -e HOME=/tmp/home -e DUET_TEST_IN_DOCKER=1 oven/bun:1.3.11 sh -lc 'cp -R /src/. /work && bun install --frozen-lockfile && bun test ./evals/*.eval.ts'",
+        "format": "oxfmt --write --no-error-on-unmatched-pattern",
+        "format:check": "oxfmt --check --no-error-on-unmatched-pattern",
+        "lint": "oxlint src/",
+        "prepack": "bun run build",
+        "test": "docker run --rm -v \"$PWD:/src:ro\" -w /work -e HOME=/tmp/home -e DUET_TEST_IN_DOCKER=1 oven/bun:1.3.11 sh -lc 'cp -R /src/. /work && bun install --frozen-lockfile && bun test ./test/*.test.ts'",
+        "example": "bun examples/basic.ts",
+        "example:state-machine": "bun examples/state-machine.ts",
+        "prepare": "husky",
+        "build:compile": "bun build src/cli.ts --compile --outfile dist/duet"
+    },
+    "dependencies": {
+        "@earendil-works/pi-agent-core": "^0.74.0",
+        "@earendil-works/pi-ai": "^0.74.0",
+        "@earendil-works/pi-coding-agent": "^0.74.0",
+        "@electric-sql/pglite": "^0.4.5",
+        "@opentui/core": "^0.2.2",
+        "ajv": "^8.20.0",
+        "dedent": "^1.7.2",
+        "dotenv": "^17.4.2",
+        "eventemitter3": "^5.0.0",
+        "jstoxml": "^7.1.0",
+        "nanoid": "^5.0.0",
+        "typebox": "^1.1.24"
+    },
+    "devDependencies": {
+        "@types/bun": "^1.3.13",
+        "@types/node": "^22.0.0",
+        "husky": "^9.1.7",
+        "oxfmt": "^0.47.0",
+        "oxlint": "^0.16.0",
+        "tsx": "^4.19.0",
+        "typescript": "^5.7.0"
+    },
+    "engines": {
+        "node": ">=20"
+    },
+    "packageManager": "bun@1.3.11"
+}

package/dist/src/cli.d.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env bun
+/**
+ * duet CLI
+ *
+ * Usage:
+ *   duet "build a todo app in React"
+ *   duet --model claude-opus-4-7 "refactor auth system"
+ *   echo "fix the bug in server.ts" | duet
+ */
+declare const PACKAGE_MANAGERS: readonly ["npm", "bun", "pnpm", "yarn"];
+type PackageManager = (typeof PACKAGE_MANAGERS)[number];
+type PackageManagerDetectionContext = {
+    userAgent?: string;
+    runtimeExecutable?: string;
+    cliFilePath?: string;
+    scriptPath?: string;
+};
+export declare function parseResumeHistoryLines(value: string, optionName?: string): number;
+export declare function formatNewVersionNotice(packageName: string, currentVersion: string, latestVersion: string): string;
+export declare function compareSemverVersions(left: string, right: string): number;
+export declare function detectPackageManagerFromContext(context: PackageManagerDetectionContext): PackageManager;
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/src/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":";AAEA;;;;;;;GAOG;AAwBH,QAAA,MAAM,gBAAgB,yCAA0C,CAAC;AAEjE,KAAK,cAAc,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAExD,KAAK,8BAA8B,GAAG;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAqZF,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,MAAM,EACb,UAAU,SAA2B,GACpC,MAAM,CAKR;AAeD,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,GACpB,MAAM,CAER;AAmBD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAWzE;AA+FD,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,8BAA8B,GACtC,cAAc,CAiBhB"}