syncpoint-ai 0.1.0

package/README.md

@@ -0,0 +1,307 @@
+<div align="center">
+
+# SyncPoint
+
+**Stop agent drift before it becomes a merge conflict.**
+
+A local coordination protocol for AI agents that share resources.
+
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.5-blue?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+[![Node.js](https://img.shields.io/badge/Node.js-%E2%89%A520-green?logo=node.js&logoColor=white)](https://nodejs.org/)
+[![pnpm](https://img.shields.io/badge/pnpm-%E2%89%A59-orange?logo=pnpm)](https://pnpm.io/)
+[![SQLite](https://img.shields.io/badge/SQLite-local--first-003B57?logo=sqlite&logoColor=white)](https://sqlite.org/)
+[![MCP](https://img.shields.io/badge/MCP-editor--agent%20ready-purple)](packages/syncpoint-mcp)
+
+</div>
+
+**English** · [中文](README_zh-CN.md)
+
+---
+
+## The Problem
+
+AI coding agents fail not because they write bad code — but because they **continue from different realities**.
+
+- Agent A owns `shared-config.ts`. Agent B edits it anyway. Neither knows.
+- A checkpoint goes stale. Another agent resumes from it and builds on wrong assumptions.
+- A handoff loses the blockers, risks, and review state the previous agent built up.
+- A hard constraint says "don't touch the auth module." The agent touches it. Nothing stops it.
+
+By the time you notice, the damage is a merge conflict — or worse, silently wrong code in production.
+
+## What SyncPoint Does
+
+SyncPoint checks whether an agent's continuation path is safe **before** the agent proceeds. If it isn't, SyncPoint **blocks** — not with a warning in a prompt, but with a hard protocol gate the agent cannot skip.
+
+---
+
+## Four Experiences
+
+### 1. Collision Detection
+
+Two agents claim the same file. SyncPoint creates a SyncGate — a hard stop that neither agent can ignore.
+
+```bash
+# Start the server
+pnpm build && pnpm --filter syncpoint-server dev
+
+# Terminal A — agent-a claims a file exclusively
+syncpoint claim src/shared-config.ts --agent agent-a --mode exclusive
+
+# Terminal B — agent-b tries to claim the same file
+syncpoint claim src/shared-config.ts --agent agent-b --mode exclusive
+# → BLOCKED. agent-b sees who holds the lock and why.
+
+# See the full state
+syncpoint status
+# → Shows: agent-b is blocked because agent-a has an exclusive claim
+```
+
+The blocked agent doesn't just get an error message. SyncPoint creates a **SyncGate** — a synchronization barrier that both agents can see. The gate stays open until the conflict is explicitly resolved. Neither agent can silently proceed.
+
+### 2. Stale Resume Detection
+
+Agent-a checkpoints mid-task. Meanwhile, agent-b changes related dependencies. When agent-a resumes, SyncPoint detects the stale context.
+
+```bash
+# agent-a saves progress
+syncpoint checkpoint --agent agent-a --summary "Auth module halfway done"
+
+# ... time passes, other agents make changes ...
+
+# agent-a tries to resume
+syncpoint resume --agent agent-a
+
+# SyncPoint checks:
+#   - Is the checkpoint still fresh?
+#   - Did other agents touch related resources?
+#   - Are there new constraints or blockers?
+#
+# If stale → warnings and blockers are injected into the resume output.
+# The agent sees: "Your assumptions may be outdated."
+```
+
+Without SyncPoint, the agent resumes from a stale snapshot and silently produces code based on assumptions that no longer hold. With SyncPoint, the staleness is caught at the resume boundary.
+
+### 3. Structured Handoff
+
+Agent-a finishes frontend work and hands off to agent-b for backend. SyncPoint transfers not just a text summary, but a complete structured state.
+
+```bash
+# agent-a hands off to agent-b
+syncpoint loop handoff \
+  --task <taskId> \
+  --from agent-a \
+  --to agent-b \
+  --context "Login page complete. API uses JWT, token expiry 1h"
+
+# agent-b resumes — receives:
+#   ✓ Context snapshot (working resources, completed work, blockers)
+#   ✓ Constraint state (active rules, do-not-touch scopes)
+#   ✓ Resource ownership (what agent-a claimed, what's released)
+#   ✓ Unresolved gates (any pending sync obligations)
+```
+
+A handoff is not "send a message about what I did." It is a **structured state transfer** — task context, resource ownership, active constraints, and unresolved blockers, all packaged together. The receiving agent gets a complete reality projection, not a text summary that might miss critical details.
+
+### 4. Hard Constraints
+
+Set a constraint that no agent may touch a protected scope. SyncPoint enforces it at the execution boundary — not in the agent's prompt.
+
+```bash
+# Add a hard constraint via project memory
+syncpoint project-memory add \
+  --content "Auth module under audit — do not modify" \
+  --kind hard_constraint \
+  --applies-to '{"files":["src/auth/**"]}' \
+  --severity blocking \
+  --validator-type resource_forbidden
+
+# Any agent that tries to claim or modify files under src/auth/ gets blocked
+syncpoint claim src/auth/middleware.ts --agent rogue-agent
+# → BLOCKED by Constraint Evaluation
+
+# Verify constraints
+syncpoint constraint check --action resume --task <taskId> --agent <agentId>
+```
+
+The key difference: constraints live in SyncPoint's execution layer, not in the agent's prompt. An agent prompt can be ignored. A SyncPoint constraint **cannot**. This is the difference between "please don't touch this" and "you physically cannot touch this."
+
+---
+
+## Quick Start
+
+```bash
+# Install dependencies and build
+pnpm install
+pnpm build
+
+# Initialize SyncPoint in your project
+syncpoint init
+
+# Run the demo — shows collision detection in action
+syncpoint demo
+
+# Stop at the blocked state to inspect
+syncpoint demo --stage blocked
+syncpoint status
+```
+
+Without global install:
+
+```bash
+node packages/syncpoint-cli/dist/main.js demo
+node packages/syncpoint-cli/dist/main.js status
+```
+
+## Declaring Agents
+
+Creating a manifest file in `.syncpoint/agents/` registers the agent automatically:
+
+```yaml
+# .syncpoint/agents/my-agent.yml
+version: 1
+name: my-agent
+provider: auto_detect
+profile: general
+role: executor
+```
+
+```bash
+syncpoint agent list       # See all declared agents
+syncpoint agent diagnose   # Check for issues
+```
+
+## Editor Integration
+
+SyncPoint exposes the same protocol through MCP for editor agents.
+
+### Cursor `.cursor/mcp.json`
+
+```json
+{
+  "mcpServers": {
+    "syncpoint": {
+      "command": "node",
+      "args": ["<SYNCPOINT_REPO>/packages/syncpoint-mcp/dist/main.js"],
+      "env": {
+        "SYNCPOINT_PROJECT_ROOT": "<YOUR_PROJECT_ROOT>"
+      }
+    }
+  }
+}
+```
+
+### VS Code `.vscode/mcp.json`
+
+```json
+{
+  "servers": {
+    "syncpoint": {
+      "type": "stdio",
+      "command": "node",
+      "args": ["<SYNCPOINT_REPO>/packages/syncpoint-mcp/dist/main.js"],
+      "env": {
+        "SYNCPOINT_PROJECT_ROOT": "${workspaceFolder}"
+      }
+    }
+  }
+}
+```
+
+## How It Works
+
+SyncPoint enforces boundaries through five protocol primitives:
+
+| Primitive | What it does |
+|---|---|
+| **ResourceClaim** | Agent declares "I will touch these resources" — overlapping claims create blockers |
+| **SyncGate** | A hard stop — cannot continue until the gate is resolved |
+| **CheckpointReview** | A checkpoint that requires approval before another agent can resume from it |
+| **Operation** | A tracked change checked for ownership, conflicts, and constraints before apply |
+| **Wake** | A sync obligation — notifies an agent to review, approve, or acknowledge |
+
+The core loop: **pause → sync → resume**.
+
+When an agent tries to continue, SyncPoint checks:
+
+- Do working resources overlap a protected scope? → blocked
+- Is there an unresolved ownership conflict? → blocked
+- Is there an open gate or pending review? → blocked
+- Is the checkpoint stale? → blocked
+
+If everything is clean, the agent continues. If not, the specific blocker is surfaced with the reason and what needs to happen to unblock.
+
+## What SyncPoint Is Not
+
+| It is not | Why |
+|---|---|
+| Agent runner | Does not call model APIs or run autonomous loops |
+| Workflow builder | Does not build DAGs or visual flows |
+| File lock daemon | Protocol-level enforcement, not OS-level (see [enforcement design](docs/system-file-lock-design.md)) |
+| Memory product | Project memory supports synchronization, not generic recall |
+
+**SyncPoint is the layer agents call before they continue.**
+
+## Repository Layout
+
+```text
+packages/
+├── syncpoint-kernel         # Pure types, validators, state machines, errors
+├── syncpoint-context        # Memory, reality projection, context policy
+├── syncpoint-governance     # Constraint evaluation, checkpoint review, wake engine
+├── syncpoint-adapters       # Agent manifests, negotiation, orchestration, runtime
+├── syncpoint-core           # Facade — re-exports kernel, context, governance, adapters
+├── syncpoint-server         # Application services, SQLite, tRPC, SSE
+├── syncpoint-cli            # Operator CLI
+├── syncpoint-mcp            # MCP adapter for editor AI agents
+├── syncpoint-sdk            # Typed client for integrations
+├── syncpoint-plugin-generic-agent  # Generic resource plugin
+└── vscode-extension         # Sync View panel
+```
+
+Dependency order: `kernel → context → governance → adapters → core → server → cli, mcp, sdk`
+
+## Tech Stack
+
+| Layer | Technology |
+|---|---|
+| Language | TypeScript |
+| Runtime | Node.js |
+| Package manager | pnpm workspaces |
+| Database | SQLite + Drizzle ORM |
+| API | tRPC |
+| Validation | Zod |
+| Tests | Vitest |
+| Editor integration | MCP + VS Code extension |
+
+## Documentation
+
+| Document | Best for |
+|---|---|
+| [`docs/core-synchronization.md`](docs/core-synchronization.md) | Protocol primitives and invariants |
+| [`docs/reality-runtime.md`](docs/reality-runtime.md) | Layered reality architecture |
+| [`docs/constraint-runtime.md`](docs/constraint-runtime.md) | Constraint evaluation rules and enforcement |
+| [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) | Layer boundaries and code placement |
+| [`docs/beyond-code.md`](docs/beyond-code.md) | SyncPoint for non-code resources |
+| [`docs/local-operations-guide.md`](docs/local-operations-guide.md) | Operating SyncPoint with CLI, MCP, server |
+| [`docs/migration-guide.md`](docs/migration-guide.md) | Migrating to manifest-based agent registration |
+
+## Examples
+
+| Scenario | Directory | What it shows |
+|---|---|---|
+| File conflict | [`examples/conflict`](examples/conflict) | Two agents claim the same file — blocked |
+| Stale resume | [`examples/stale-resume`](examples/stale-resume) | Resume from outdated checkpoint — warned |
+| Handoff | [`examples/handoff`](examples/handoff) | Structured context transfer between agents |
+| Review gate | [`examples/review-gate`](examples/review-gate) | Checkpoint requires approval — blocked |
+
+For the interactive version, run `syncpoint demo`.
+
+---
+
+<div align="center">
+
+**SyncPoint helps multiple AI agents stop, align, and continue safely.**
+
+</div>

package/dist/adapters/adapter.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Agent Adapter Protocol — standardized interface for AI editor integration.
+ *
+ * Each adapter defines how a specific AI editor (Codex, Claude Code, Cursor, Cline)
+ * should consume SyncPoint's resume context at key lifecycle moments:
+ *
+ *   onBoot    — agent starts fresh or is assigned a task
+ *   onResume  — agent resumes after pause / context switch
+ *   onHandoff — agent receives a task handoff from another agent
+ *
+ * The adapter protocol does NOT control the editor directly.
+ * It produces the correct files and instructions so that the editor's native
+ * mechanism picks up the narrowed context.
+ */
+import { z } from "zod";
+import type { ResumeContext } from "../context/index.js";
+import type { PromptFormat } from "../context/index.js";
+export declare const AgentProvider: z.ZodEnum<["codex", "claude-code", "cursor", "cline", "copilot", "human", "other"]>;
+export type AgentProvider = z.infer<typeof AgentProvider>;
+export declare const AdapterLifecycleEvent: z.ZodEnum<["boot", "resume", "handoff", "checkpoint"]>;
+export type AdapterLifecycleEvent = z.infer<typeof AdapterLifecycleEvent>;
+export declare const AdapterInstructionSchema: z.ZodObject<{
+    /** Lifecycle event that triggered this instruction */
+    event: z.ZodEnum<["boot", "resume", "handoff", "checkpoint"]>;
+    /** Provider this instruction targets */
+    provider: z.ZodEnum<["codex", "claude-code", "cursor", "cline", "copilot", "human", "other"]>;
+    /** Files to write (relative path → content) */
+    files: z.ZodRecord<z.ZodString, z.ZodString>;
+    /** Formatted prompt text for clipboard / system prompt injection */
+    promptText: z.ZodString;
+    /** Format used for the primary rules file */
+    primaryFormat: z.ZodString;
+    /** Human-readable summary of what the adapter did */
+    summary: z.ZodString;
+    /** Warnings from resume context */
+    warnings: z.ZodArray<z.ZodString, "many">;
+    /** Whether the context is ready */
+    ready: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    summary: string;
+    warnings: string[];
+    ready: boolean;
+    files: Record<string, string>;
+    event: "checkpoint" | "handoff" | "resume" | "boot";
+    provider: "human" | "codex" | "claude-code" | "cursor" | "cline" | "copilot" | "other";
+    promptText: string;
+    primaryFormat: string;
+}, {
+    summary: string;
+    warnings: string[];
+    ready: boolean;
+    files: Record<string, string>;
+    event: "checkpoint" | "handoff" | "resume" | "boot";
+    provider: "human" | "codex" | "claude-code" | "cursor" | "cline" | "copilot" | "other";
+    promptText: string;
+    primaryFormat: string;
+}>;
+export type AdapterInstruction = z.infer<typeof AdapterInstructionSchema>;
+export interface AdapterConfig {
+    /** Which provider this adapter serves */
+    provider: AgentProvider;
+    /** Primary rules file format */
+    rulesFormat: PromptFormat;
+    /** File path for the primary rules file (relative to project root) */
+    rulesFile: string;
+    /** Additional files to generate */
+    extraFiles: {
+        path: string;
+        format: PromptFormat;
+    }[];
+    /** System prompt preamble injected before resume context */
+    preamble: string;
+    /** Instructions shown to the user about how to configure the editor */
+    setupInstructions: string;
+}
+export declare const ADAPTER_CONFIGS: Record<string, AdapterConfig>;
+import type { RealityProjection } from "../context/index.js";
+/**
+ * Build an AdapterInstruction for a given provider and lifecycle event.
+ * This produces the file contents and prompt text that should be written
+ * to the project directory so the editor picks up the narrowed context.
+ */
+export declare function buildAdapterInstruction(ctx: ResumeContext, provider: AgentProvider, event?: AdapterLifecycleEvent, projection?: RealityProjection | null): AdapterInstruction;
+/**
+ * Get adapter config for a provider. Returns undefined if not found.
+ */
+export declare function getAdapterConfig(provider: string): AdapterConfig | undefined;
+/**
+ * List all known adapter provider names.
+ */
+export declare function listAdapterProviders(): string[];
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapters/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../_build/src/adapters/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAIxD,eAAO,MAAM,aAAa,qFAQxB,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAI1D,eAAO,MAAM,qBAAqB,wDAKhC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAI1E,eAAO,MAAM,wBAAwB;IACnC,sDAAsD;;IAEtD,wCAAwC;;IAExC,+CAA+C;;IAE/C,oEAAoE;;IAEpE,6CAA6C;;IAE7C,qDAAqD;;IAErD,mCAAmC;;IAEnC,mCAAmC;;;;;;;;;;;;;;;;;;;;EAEnC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAI1E,MAAM,WAAW,aAAa;IAC5B,yCAAyC;IACzC,QAAQ,EAAE,aAAa,CAAC;IACxB,gCAAgC;IAChC,WAAW,EAAE,YAAY,CAAC;IAC1B,sEAAsE;IACtE,SAAS,EAAE,MAAM,CAAC;IAClB,mCAAmC;IACnC,UAAU,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,YAAY,CAAA;KAAE,EAAE,CAAC;IACrD,4DAA4D;IAC5D,QAAQ,EAAE,MAAM,CAAC;IACjB,uEAAuE;IACvE,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAID,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CA+EzD,CAAC;AAKF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,aAAa,EAClB,QAAQ,EAAE,aAAa,EACvB,KAAK,GAAE,qBAAgC,EACvC,UAAU,CAAC,EAAE,iBAAiB,GAAG,IAAI,GACpC,kBAAkB,CA8BpB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAE5E;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,EAAE,CAE/C"}

package/dist/adapters/adapter.js

@@ -0,0 +1,163 @@
+/**
+ * Agent Adapter Protocol — standardized interface for AI editor integration.
+ *
+ * Each adapter defines how a specific AI editor (Codex, Claude Code, Cursor, Cline)
+ * should consume SyncPoint's resume context at key lifecycle moments:
+ *
+ *   onBoot    — agent starts fresh or is assigned a task
+ *   onResume  — agent resumes after pause / context switch
+ *   onHandoff — agent receives a task handoff from another agent
+ *
+ * The adapter protocol does NOT control the editor directly.
+ * It produces the correct files and instructions so that the editor's native
+ * mechanism picks up the narrowed context.
+ */
+import { z } from "zod";
+// ── Provider enum ────────────────────────────────────
+export const AgentProvider = z.enum([
+    "codex",
+    "claude-code",
+    "cursor",
+    "cline",
+    "copilot",
+    "human",
+    "other",
+]);
+// ── Lifecycle events ─────────────────────────────────
+export const AdapterLifecycleEvent = z.enum([
+    "boot",
+    "resume",
+    "handoff",
+    "checkpoint",
+]);
+// ── Adapter instruction ──────────────────────────────
+export const AdapterInstructionSchema = z.object({
+    /** Lifecycle event that triggered this instruction */
+    event: AdapterLifecycleEvent,
+    /** Provider this instruction targets */
+    provider: AgentProvider,
+    /** Files to write (relative path → content) */
+    files: z.record(z.string()),
+    /** Formatted prompt text for clipboard / system prompt injection */
+    promptText: z.string(),
+    /** Format used for the primary rules file */
+    primaryFormat: z.string(),
+    /** Human-readable summary of what the adapter did */
+    summary: z.string(),
+    /** Warnings from resume context */
+    warnings: z.array(z.string()),
+    /** Whether the context is ready */
+    ready: z.boolean(),
+});
+// ── Built-in adapter configs ─────────────────────────
+export const ADAPTER_CONFIGS = {
+    cursor: {
+        provider: "cursor",
+        rulesFormat: "cursorrules",
+        rulesFile: ".cursorrules",
+        extraFiles: [],
+        preamble: "You are working on a SyncPoint-managed project. " +
+            "The rules below are your ONLY source of task context. " +
+            "Do NOT use previous conversation history.",
+        setupInstructions: "Cursor reads .cursorrules automatically from the project root.\n" +
+            "Run `syncpoint adapter boot` after each resume or handoff.\n" +
+            "The .cursorrules file will be overwritten with the latest context.",
+    },
+    "claude-code": {
+        provider: "claude-code",
+        rulesFormat: "agents-md",
+        rulesFile: "AGENTS.md",
+        extraFiles: [
+            { path: ".syncpoint/resume-prompt.md", format: "system-prompt" },
+        ],
+        preamble: "You are working on a SyncPoint-managed project. " +
+            "Read AGENTS.md for your current task context. " +
+            "Do NOT carry over previous conversation history.",
+        setupInstructions: "Claude Code reads AGENTS.md as project knowledge.\n" +
+            "Run `syncpoint adapter boot` after each resume or handoff.\n" +
+            "Start new conversations with: /read AGENTS.md",
+    },
+    codex: {
+        provider: "codex",
+        rulesFormat: "agents-md",
+        rulesFile: "AGENTS.md",
+        extraFiles: [
+            { path: ".syncpoint/resume-prompt.md", format: "system-prompt" },
+        ],
+        preamble: "You are working on a SyncPoint-managed project. " +
+            "Read AGENTS.md for your current task context. " +
+            "Do NOT carry over previous conversation history.",
+        setupInstructions: "Codex reads AGENTS.md as project context.\n" +
+            "Run `syncpoint adapter boot` after each resume or handoff.\n" +
+            "Pass --system-prompt from .syncpoint/resume-prompt.md when using API.",
+    },
+    cline: {
+        provider: "cline",
+        rulesFormat: "system-prompt",
+        rulesFile: ".syncpoint/resume-prompt.md",
+        extraFiles: [
+            { path: ".cursorrules", format: "cursorrules" },
+        ],
+        preamble: "You are working on a SyncPoint-managed project. " +
+            "The system prompt below is your ONLY source of task context. " +
+            "Do NOT use previous conversation history.",
+        setupInstructions: "Cline uses system prompts from its settings.\n" +
+            "Run `syncpoint adapter boot` after each resume or handoff.\n" +
+            "Copy .syncpoint/resume-prompt.md into Cline's custom system prompt field.",
+    },
+    copilot: {
+        provider: "copilot",
+        rulesFormat: "agents-md",
+        rulesFile: "AGENTS.md",
+        extraFiles: [],
+        preamble: "You are working on a SyncPoint-managed project. " +
+            "Read AGENTS.md for context.",
+        setupInstructions: "GitHub Copilot reads AGENTS.md for project context.\n" +
+            "Run `syncpoint adapter boot` after each resume or handoff.",
+    },
+};
+// ── Build adapter instruction ────────────────────────
+import { formatResumePrompt } from "../context/index.js";
+/**
+ * Build an AdapterInstruction for a given provider and lifecycle event.
+ * This produces the file contents and prompt text that should be written
+ * to the project directory so the editor picks up the narrowed context.
+ */
+export function buildAdapterInstruction(ctx, provider, event = "resume", projection) {
+    const config = ADAPTER_CONFIGS[provider] ?? ADAPTER_CONFIGS["cursor"];
+    const files = {};
+    // Primary rules file — P2: pass projection to all formats
+    const primaryContent = formatResumePrompt(ctx, config.rulesFormat, projection);
+    files[config.rulesFile] = primaryContent;
+    // Extra files
+    for (const extra of config.extraFiles) {
+        files[extra.path] = formatResumePrompt(ctx, extra.format, projection);
+    }
+    // Prompt text for clipboard / API injection
+    const promptText = config.preamble + "\n\n" + formatResumePrompt(ctx, "system-prompt", projection);
+    const fileList = Object.keys(files).join(", ");
+    const summary = `[${event}] ${config.provider}: wrote ${fileList}`;
+    return {
+        event,
+        provider: config.provider,
+        files,
+        promptText,
+        primaryFormat: config.rulesFormat,
+        summary,
+        warnings: ctx.warnings,
+        ready: ctx.ready,
+    };
+}
+/**
+ * Get adapter config for a provider. Returns undefined if not found.
+ */
+export function getAdapterConfig(provider) {
+    return ADAPTER_CONFIGS[provider];
+}
+/**
+ * List all known adapter provider names.
+ */
+export function listAdapterProviders() {
+    return Object.keys(ADAPTER_CONFIGS);
+}
+//# sourceMappingURL=adapter.js.map

package/dist/adapters/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../../_build/src/adapters/adapter.ts"],"names":[],"mappings":"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"}