agent-relay 1.6.0 → 2.0.0

package/packages/config/dist/schemas.js

@@ -0,0 +1,180 @@
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+const withId = (schema, id) => Object.assign(schema, { $id: id });
+// Relay connection defaults (used by daemon + wrapper)
+export const ConnectionConfigSchema = z.object({
+    maxFrameBytes: z.number().int().positive(),
+    heartbeatMs: z.number().int().positive(),
+    heartbeatTimeoutMultiplier: z.number().int().positive(),
+    maxWriteQueueSize: z.number().int().nonnegative(),
+    writeQueueHighWaterMark: z.number().int().nonnegative(),
+    writeQueueLowWaterMark: z.number().int().nonnegative(),
+});
+export const TmuxWrapperConfigSchema = z.object({
+    pollInterval: z.number().int().positive(),
+    idleBeforeInjectMs: z.number().int().nonnegative(),
+    injectRetryMs: z.number().int().nonnegative(),
+    debug: z.boolean(),
+    debugLogIntervalMs: z.number().int().nonnegative(),
+    mouseMode: z.boolean(),
+    activityIdleThresholdMs: z.number().int().nonnegative(),
+    outputStabilityTimeoutMs: z.number().int().nonnegative(),
+    outputStabilityPollMs: z.number().int().nonnegative(),
+    streamLogs: z.boolean(),
+});
+export const RelayRuntimeConfigSchema = z.object({
+    trajectories: z
+        .object({
+        storeInRepo: z.boolean().optional(),
+    })
+        .optional(),
+});
+export const BridgeConfigSchema = z.object({
+    projects: z
+        .record(z.object({
+        lead: z.string().optional(),
+        cli: z.string().optional(),
+    }))
+        .optional(),
+    defaultCli: z.string().optional(),
+});
+export const TeamsConfigSchema = z.object({
+    team: z.string(),
+    agents: z
+        .array(z.object({
+        name: z.string(),
+        cli: z.string(),
+        role: z.string().optional(),
+        task: z.string().optional(),
+    }))
+        .default([]),
+    autoSpawn: z.boolean().optional(),
+});
+export const ShadowRoleConfigSchema = z.object({
+    prompt: z.string().optional(),
+    speakOn: z.array(z.string()).default([]),
+});
+export const ShadowPairConfigSchema = z.object({
+    shadow: z.string(),
+    shadowRole: z.string().optional(),
+    speakOn: z.array(z.string()).optional(),
+});
+export const ShadowConfigSchema = z.object({
+    shadows: z
+        .object({
+        pairs: z.record(ShadowPairConfigSchema).optional(),
+        roles: z.record(ShadowRoleConfigSchema).optional(),
+    })
+        .optional(),
+});
+export const AgentFrontmatterSchema = z.object({
+    name: z.string().optional(),
+    model: z.string().optional(),
+    description: z.string().optional(),
+    agentType: z.string().optional(),
+    role: z.string().optional(),
+    'allowed-tools': z.string().optional(),
+});
+export const CLIAuthConfigSchema = z.object({
+    command: z.string(),
+    args: z.array(z.string()),
+    deviceFlowArgs: z.array(z.string()).optional(),
+    urlPattern: z.instanceof(RegExp),
+    credentialPath: z.string().optional(),
+    displayName: z.string(),
+    prompts: z
+        .array(z.object({
+        pattern: z.instanceof(RegExp),
+        response: z.string(),
+        delay: z.number().int().nonnegative().optional(),
+        description: z.string(),
+    }))
+        .default([]),
+    successPatterns: z.array(z.instanceof(RegExp)).default([]),
+    errorPatterns: z
+        .array(z.object({
+        pattern: z.instanceof(RegExp),
+        message: z.string(),
+        recoverable: z.boolean(),
+        hint: z.string().optional(),
+    }))
+        .optional(),
+    waitTimeout: z.number().int().nonnegative(),
+    supportsDeviceFlow: z.boolean().optional(),
+});
+export const CloudConfigSchema = z.object({
+    port: z.number().int(),
+    publicUrl: z.string(),
+    appUrl: z.string(),
+    sessionSecret: z.string(),
+    localDashboardUrl: z.string().optional(),
+    databaseUrl: z.string(),
+    redisUrl: z.string(),
+    github: z.object({
+        clientId: z.string(),
+        clientSecret: z.string(),
+        webhookSecret: z.string().optional(),
+    }),
+    providers: z
+        .object({
+        anthropic: z.object({ clientId: z.string() }).optional(),
+        openai: z.object({ clientId: z.string() }).optional(),
+        google: z
+            .object({
+            clientId: z.string(),
+            clientSecret: z.string(),
+        })
+            .optional(),
+    })
+        .default({}),
+    vault: z.object({
+        masterKey: z.string(),
+    }),
+    compute: z.object({
+        provider: z.enum(['fly', 'railway', 'docker']),
+        fly: z
+            .object({
+            apiToken: z.string(),
+            org: z.string(),
+            region: z.string().optional(),
+            workspaceDomain: z.string().optional(),
+            registryAuth: z
+                .object({
+                username: z.string(),
+                password: z.string(),
+            })
+                .optional(),
+            snapshotRetentionDays: z.number().int().optional(),
+            volumeSizeGb: z.number().int().optional(),
+        })
+            .optional(),
+        railway: z
+            .object({
+            apiToken: z.string(),
+        })
+            .optional(),
+    }),
+    nango: z.object({
+        secretKey: z.string(),
+        host: z.string().optional(),
+    }),
+    stripe: z.object({
+        secretKey: z.string(),
+        publishableKey: z.string(),
+        webhookSecret: z.string(),
+        priceIds: z.record(z.string().optional()),
+    }),
+    adminUsers: z.array(z.string()),
+});
+export const jsonSchemas = {
+    connection: withId(zodToJsonSchema(ConnectionConfigSchema, { target: 'jsonSchema7' }), 'RelayConnectionConfig'),
+    tmuxWrapper: withId(zodToJsonSchema(TmuxWrapperConfigSchema, { target: 'jsonSchema7' }), 'RelayTmuxWrapperConfig'),
+    relayRuntime: withId(zodToJsonSchema(RelayRuntimeConfigSchema, { target: 'jsonSchema7' }), 'RelayRuntimeConfig'),
+    bridge: withId(zodToJsonSchema(BridgeConfigSchema, { target: 'jsonSchema7' }), 'BridgeConfig'),
+    teams: withId(zodToJsonSchema(TeamsConfigSchema, { target: 'jsonSchema7' }), 'TeamsConfig'),
+    shadow: withId(zodToJsonSchema(ShadowConfigSchema, { target: 'jsonSchema7' }), 'ShadowConfig'),
+    agentFrontmatter: withId(zodToJsonSchema(AgentFrontmatterSchema, { target: 'jsonSchema7' }), 'AgentFrontmatter'),
+    cliAuth: withId(zodToJsonSchema(CLIAuthConfigSchema, { target: 'jsonSchema7' }), 'CLIAuthConfig'),
+    cloud: withId(zodToJsonSchema(CloudConfigSchema, { target: 'jsonSchema7' }), 'CloudConfig'),
+};
+//# sourceMappingURL=schemas.js.map

package/packages/config/dist/shadow-config.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Shadow Agent Configuration
+ * Handles loading and parsing shadow agent configuration from .agent-relay.json.
+ *
+ * Configuration can be placed in:
+ * - Project root: ./.agent-relay.json
+ * - Agent-relay dir: ./.agent-relay/config.json
+ *
+ * Shadow configuration structure:
+ * {
+ *   "shadows": {
+ *     "pairs": {
+ *       "Lead": { "shadow": "Auditor", "shadowRole": "reviewer" }
+ *     },
+ *     "roles": {
+ *       "reviewer": { "prompt": "Review code...", "speakOn": ["CODE_WRITTEN"] }
+ *     }
+ *   }
+ * }
+ */
+import type { SpeakOnTrigger } from '@agent-relay/protocol/types';
+/** Shadow role definition */
+export interface ShadowRoleConfig {
+    /** System prompt for this shadow role */
+    prompt?: string;
+    /** Triggers for when the shadow should speak */
+    speakOn: SpeakOnTrigger[];
+}
+/** Shadow pair definition */
+export interface ShadowPairConfig {
+    /** Name of the shadow agent */
+    shadow: string;
+    /** Role name (references roles config) or preset (reviewer, auditor, active) */
+    shadowRole?: string;
+    /** Override speakOn triggers (takes precedence over role) */
+    speakOn?: SpeakOnTrigger[];
+    /** CLI to use for shadow (defaults to same as primary) */
+    cli?: string;
+}
+/** Shadow configuration section */
+export interface ShadowConfig {
+    /** Primary -> Shadow mappings */
+    pairs: Record<string, ShadowPairConfig>;
+    /** Role definitions */
+    roles?: Record<string, ShadowRoleConfig>;
+}
+/** Full agent-relay configuration file structure */
+export interface AgentRelayConfig {
+    /** Shadow agent configuration */
+    shadows?: ShadowConfig;
+}
+/** Resolved shadow config for a primary agent */
+export interface ResolvedShadowConfig {
+    /** Shadow agent name */
+    shadowName: string;
+    /** Role name (for logging/display) */
+    roleName?: string;
+    /** Resolved speakOn triggers */
+    speakOn: SpeakOnTrigger[];
+    /** System prompt for the shadow */
+    prompt?: string;
+    /** CLI to use for shadow */
+    cli?: string;
+}
+/**
+ * Load agent-relay configuration from project root
+ * Returns null if no config found
+ */
+export declare function loadAgentRelayConfig(projectRoot: string): AgentRelayConfig | null;
+/**
+ * Get shadow configuration for a primary agent
+ * Returns null if no shadow configured for this agent
+ */
+export declare function getShadowForAgent(projectRoot: string, primaryAgentName: string): ResolvedShadowConfig | null;
+/**
+ * Get all configured shadow pairs
+ */
+export declare function getAllShadowPairs(projectRoot: string): Map<string, ResolvedShadowConfig>;
+/**
+ * Check if shadow config exists
+ */
+export declare function hasShadowConfig(projectRoot: string): boolean;
+/**
+ * Get the config file path that would be used
+ */
+export declare function getConfigPath(projectRoot: string): string | null;
+//# sourceMappingURL=shadow-config.d.ts.map

package/packages/config/dist/trajectory-config.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Trajectory Configuration
+ *
+ * Manages centralized relay configuration for trajectory storage settings.
+ * Config is stored in a central location (not per-repo) and applies to all projects.
+ *
+ * ARCHITECTURE:
+ * 1. Config location: Centralized, not repo-specific
+ *    - Primary: AGENT_RELAY_CONFIG_DIR/relay.json (if env var set)
+ *    - Default: ~/.config/agent-relay/relay.json
+ *    - Reasoning: Single config applies to all projects; survives repo deletion
+ *
+ * 2. Default behavior: trajectories are OPT-OUT (stored in user home)
+ *    - Location: ~/.config/agent-relay/trajectories/<project-hash>/
+ *    - Users can opt-in via central config: storeInRepo: true
+ *
+ * 3. Opt-in storage: .trajectories/ directory in repo root
+ *    - Applied when: User sets storeInRepo: true in central relay.json
+ *    - Users should add .trajectories/ to .gitignore if private
+ *
+ * 4. Initialization: When users initialize relay in a repo, prompt to opt-in
+ *    - Creates entry in ~/.config/agent-relay/relay.json
+ *    - Does NOT create repo-specific config
+ */
+/**
+ * Relay config structure
+ */
+export interface RelayConfig {
+    /** Trajectory settings */
+    trajectories?: {
+        /**
+         * Whether to store trajectories in the repo (.trajectories/)
+         * Default: false (stored in ~/.config/agent-relay/trajectories/)
+         *
+         * NOTE: When true, this project will track trajectories in git.
+         * Users should add .trajectories/ to .gitignore if they prefer
+         * not to track trajectories for privacy reasons.
+         */
+        storeInRepo?: boolean;
+    };
+}
+/**
+ * Get the relay config file path
+ *
+ * Returns the central relay configuration file, not repo-specific.
+ * This config is shared across all projects and stored in:
+ * - AGENT_RELAY_CONFIG_DIR/relay.json (if AGENT_RELAY_CONFIG_DIR is set)
+ * - ~/.config/agent-relay/relay.json (default)
+ *
+ * NOTE: projectRoot parameter is kept for backwards compatibility but ignored.
+ * Config is always loaded from the central location.
+ */
+export declare function getRelayConfigPath(_projectRoot?: string): string;
+/**
+ * Read the relay config from the central location
+ * Config is shared across all projects
+ */
+export declare function readRelayConfig(projectRoot?: string): RelayConfig;
+/**
+ * Check if trajectories should be stored in the repo
+ */
+export declare function shouldStoreInRepo(projectRoot?: string): boolean;
+/**
+ * Get a hash of the project path for user-level storage isolation
+ */
+export declare function getProjectHash(projectRoot?: string): string;
+/**
+ * Get the user-level trajectories directory
+ */
+export declare function getUserTrajectoriesDir(projectRoot?: string): string;
+/**
+ * Get the repo-level trajectories directory
+ */
+export declare function getRepoTrajectoriesDir(projectRoot?: string): string;
+/**
+ * Get the primary trajectories directory based on config
+ * This is where new trajectories will be written
+ */
+export declare function getPrimaryTrajectoriesDir(projectRoot?: string): string;
+/**
+ * Get all trajectories directories (for reading)
+ * Returns both repo and user-level if they exist
+ */
+export declare function getAllTrajectoriesDirs(projectRoot?: string): string[];
+/**
+ * Ensure the primary trajectories directory exists
+ */
+export declare function ensureTrajectoriesDir(projectRoot?: string): string;
+/**
+ * Get trajectory environment variables for trail CLI
+ * Sets TRAJECTORIES_DATA_DIR to the appropriate location
+ */
+export declare function getTrajectoryEnvVars(projectRoot?: string): Record<string, string>;
+/**
+ * Check if project has opted into repo-level trajectory storage
+ */
+export declare function isTrajectoryOptedIn(projectRoot?: string): boolean;
+/**
+ * Get a human-readable description of where trajectories are stored
+ */
+export declare function getTrajectoriesStorageDescription(projectRoot?: string): string;
+//# sourceMappingURL=trajectory-config.d.ts.map

package/packages/config/dist/trajectory-config.js

@@ -0,0 +1,185 @@
+/**
+ * Trajectory Configuration
+ *
+ * Manages centralized relay configuration for trajectory storage settings.
+ * Config is stored in a central location (not per-repo) and applies to all projects.
+ *
+ * ARCHITECTURE:
+ * 1. Config location: Centralized, not repo-specific
+ *    - Primary: AGENT_RELAY_CONFIG_DIR/relay.json (if env var set)
+ *    - Default: ~/.config/agent-relay/relay.json
+ *    - Reasoning: Single config applies to all projects; survives repo deletion
+ *
+ * 2. Default behavior: trajectories are OPT-OUT (stored in user home)
+ *    - Location: ~/.config/agent-relay/trajectories/<project-hash>/
+ *    - Users can opt-in via central config: storeInRepo: true
+ *
+ * 3. Opt-in storage: .trajectories/ directory in repo root
+ *    - Applied when: User sets storeInRepo: true in central relay.json
+ *    - Users should add .trajectories/ to .gitignore if private
+ *
+ * 4. Initialization: When users initialize relay in a repo, prompt to opt-in
+ *    - Creates entry in ~/.config/agent-relay/relay.json
+ *    - Does NOT create repo-specific config
+ */
+import { existsSync, readFileSync, mkdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { createHash } from 'node:crypto';
+import { getProjectPaths } from './project-namespace.js';
+/**
+ * Get the central agent-relay config directory
+ * Uses AGENT_RELAY_CONFIG_DIR environment variable if set,
+ * otherwise defaults to ~/.config/agent-relay
+ */
+function getAgentRelayConfigDir() {
+    return process.env.AGENT_RELAY_CONFIG_DIR ??
+        join(homedir(), '.config', 'agent-relay');
+}
+/**
+ * Cache for config to avoid repeated file reads
+ */
+let configCache = null;
+/**
+ * Get the relay config file path
+ *
+ * Returns the central relay configuration file, not repo-specific.
+ * This config is shared across all projects and stored in:
+ * - AGENT_RELAY_CONFIG_DIR/relay.json (if AGENT_RELAY_CONFIG_DIR is set)
+ * - ~/.config/agent-relay/relay.json (default)
+ *
+ * NOTE: projectRoot parameter is kept for backwards compatibility but ignored.
+ * Config is always loaded from the central location.
+ */
+export function getRelayConfigPath(_projectRoot) {
+    return join(getAgentRelayConfigDir(), 'relay.json');
+}
+/**
+ * Read the relay config from the central location
+ * Config is shared across all projects
+ */
+export function readRelayConfig(projectRoot) {
+    const configPath = getRelayConfigPath(projectRoot);
+    // Check cache
+    if (configCache && configCache.path === configPath) {
+        try {
+            const stat = statSync(configPath);
+            if (stat.mtimeMs === configCache.mtime) {
+                return configCache.config;
+            }
+        }
+        catch {
+            // File may not exist or be readable
+        }
+    }
+    try {
+        if (!existsSync(configPath)) {
+            return {};
+        }
+        const content = readFileSync(configPath, 'utf-8');
+        const config = JSON.parse(content);
+        // Update cache
+        try {
+            const stat = statSync(configPath);
+            configCache = { path: configPath, config, mtime: stat.mtimeMs };
+        }
+        catch {
+            // Ignore cache update failures
+        }
+        return config;
+    }
+    catch (err) {
+        console.warn('[trajectory-config] Failed to read config:', err);
+        return {};
+    }
+}
+/**
+ * Check if trajectories should be stored in the repo
+ */
+export function shouldStoreInRepo(projectRoot) {
+    const config = readRelayConfig(projectRoot);
+    // Default to false - trajectories are stored outside repo by default
+    return config.trajectories?.storeInRepo === true;
+}
+/**
+ * Get a hash of the project path for user-level storage isolation
+ */
+export function getProjectHash(projectRoot) {
+    const root = projectRoot ?? getProjectPaths().projectRoot;
+    return createHash('sha256').update(root).digest('hex').slice(0, 16);
+}
+/**
+ * Get the user-level trajectories directory
+ */
+export function getUserTrajectoriesDir(projectRoot) {
+    const projectHash = getProjectHash(projectRoot);
+    const configDir = process.env.XDG_CONFIG_HOME || join(homedir(), '.config');
+    return join(configDir, 'agent-relay', 'trajectories', projectHash);
+}
+/**
+ * Get the repo-level trajectories directory
+ */
+export function getRepoTrajectoriesDir(projectRoot) {
+    const root = projectRoot ?? getProjectPaths().projectRoot;
+    return join(root, '.trajectories');
+}
+/**
+ * Get the primary trajectories directory based on config
+ * This is where new trajectories will be written
+ */
+export function getPrimaryTrajectoriesDir(projectRoot) {
+    if (shouldStoreInRepo(projectRoot)) {
+        return getRepoTrajectoriesDir(projectRoot);
+    }
+    return getUserTrajectoriesDir(projectRoot);
+}
+/**
+ * Get all trajectories directories (for reading)
+ * Returns both repo and user-level if they exist
+ */
+export function getAllTrajectoriesDirs(projectRoot) {
+    const dirs = [];
+    const repoDir = getRepoTrajectoriesDir(projectRoot);
+    if (existsSync(repoDir)) {
+        dirs.push(repoDir);
+    }
+    const userDir = getUserTrajectoriesDir(projectRoot);
+    if (existsSync(userDir)) {
+        dirs.push(userDir);
+    }
+    return dirs;
+}
+/**
+ * Ensure the primary trajectories directory exists
+ */
+export function ensureTrajectoriesDir(projectRoot) {
+    const dir = getPrimaryTrajectoriesDir(projectRoot);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+/**
+ * Get trajectory environment variables for trail CLI
+ * Sets TRAJECTORIES_DATA_DIR to the appropriate location
+ */
+export function getTrajectoryEnvVars(projectRoot) {
+    const dataDir = getPrimaryTrajectoriesDir(projectRoot);
+    return {
+        TRAJECTORIES_DATA_DIR: dataDir,
+    };
+}
+/**
+ * Check if project has opted into repo-level trajectory storage
+ */
+export function isTrajectoryOptedIn(projectRoot) {
+    return shouldStoreInRepo(projectRoot);
+}
+/**
+ * Get a human-readable description of where trajectories are stored
+ */
+export function getTrajectoriesStorageDescription(projectRoot) {
+    if (shouldStoreInRepo(projectRoot)) {
+        return `repo (.trajectories/)`;
+    }
+    return `user (~/.config/agent-relay/trajectories/)`;
+}
+//# sourceMappingURL=trajectory-config.js.map

package/packages/config/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "@agent-relay/config",
+  "version": "2.0.0",
+  "description": "Shared configuration schemas and loaders for Agent Relay",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./relay-config": {
+      "types": "./dist/relay-config.d.ts",
+      "import": "./dist/relay-config.js",
+      "default": "./dist/relay-config.js"
+    },
+    "./bridge-config": {
+      "types": "./dist/bridge-config.d.ts",
+      "import": "./dist/bridge-config.js",
+      "default": "./dist/bridge-config.js"
+    },
+    "./teams-config": {
+      "types": "./dist/teams-config.d.ts",
+      "import": "./dist/teams-config.js",
+      "default": "./dist/teams-config.js"
+    },
+    "./shadow-config": {
+      "types": "./dist/shadow-config.d.ts",
+      "import": "./dist/shadow-config.js",
+      "default": "./dist/shadow-config.js"
+    },
+    "./trajectory-config": {
+      "types": "./dist/trajectory-config.d.ts",
+      "import": "./dist/trajectory-config.js",
+      "default": "./dist/trajectory-config.js"
+    },
+    "./agent-config": {
+      "types": "./dist/agent-config.d.ts",
+      "import": "./dist/agent-config.js",
+      "default": "./dist/agent-config.js"
+    },
+    "./cli-auth-config": {
+      "types": "./dist/cli-auth-config.d.ts",
+      "import": "./dist/cli-auth-config.js",
+      "default": "./dist/cli-auth-config.js"
+    },
+    "./cloud-config": {
+      "types": "./dist/cloud-config.d.ts",
+      "import": "./dist/cloud-config.js",
+      "default": "./dist/cloud-config.js"
+    },
+    "./project-namespace": {
+      "types": "./dist/project-namespace.d.ts",
+      "import": "./dist/project-namespace.js",
+      "default": "./dist/project-namespace.js"
+    },
+    "./schemas": {
+      "types": "./dist/schemas.d.ts",
+      "import": "./dist/schemas.js",
+      "default": "./dist/schemas.js"
+    },
+    "./bridge-utils": {
+      "types": "./dist/bridge-utils.d.ts",
+      "import": "./dist/bridge-utils.js",
+      "default": "./dist/bridge-utils.js"
+    },
+    "./relay-file-writer": {
+      "types": "./dist/relay-file-writer.d.ts",
+      "import": "./dist/relay-file-writer.js",
+      "default": "./dist/relay-file-writer.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@agent-relay/protocol": "2.0.0",
+    "zod": "^3.23.8",
+    "zod-to-json-schema": "^3.23.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.3",
+    "typescript": "^5.9.3",
+    "vitest": "^3.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/packages/continuity/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './types.js';
+export * from './manager.js';
+export * from './parser.js';
+export * from './formatter.js';
+export * from './ledger-store.js';
+export * from './handoff-store.js';
+export { getContinuityManager } from './manager.js';
+export { parseContinuityCommand, hasContinuityCommand } from './parser.js';
+//# sourceMappingURL=index.d.ts.map

package/packages/continuity/dist/index.js

@@ -0,0 +1,9 @@
+export * from './types.js';
+export * from './manager.js';
+export * from './parser.js';
+export * from './formatter.js';
+export * from './ledger-store.js';
+export * from './handoff-store.js';
+export { getContinuityManager } from './manager.js';
+export { parseContinuityCommand, hasContinuityCommand } from './parser.js';
+//# sourceMappingURL=index.js.map