@webpresso/agent-kit 0.21.0

package/dist/esm/session-memory/store.js

@@ -0,0 +1,168 @@
+import { Database } from '#db/sqlite.js';
+// Search fallback is ported from context-mode's searchWithFallback design:
+// porter FTS, then trigram FTS, then IDF-weighted Levenshtein.
+const OPTIMIZE_INTERVAL = 50;
+const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS session_memory_chunks (
+  id TEXT PRIMARY KEY,
+  source TEXT NOT NULL,
+  text TEXT NOT NULL,
+  metadata_json TEXT NOT NULL,
+  created_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_session_memory_chunks_source
+  ON session_memory_chunks(source);
+CREATE VIRTUAL TABLE IF NOT EXISTS session_memory_chunks_fts
+  USING fts5(id UNINDEXED, source UNINDEXED, text, tokenize='porter');
+CREATE VIRTUAL TABLE IF NOT EXISTS session_memory_chunks_tri
+  USING fts5(id UNINDEXED, source UNINDEXED, text, tokenize='trigram');
+`;
+function tokenize(value) {
+    return value
+        .toLowerCase()
+        .split(/[^a-z0-9]+/u)
+        .filter((token) => token.length > 0);
+}
+function escapeFtsQuery(query) {
+    return tokenize(query)
+        .map((token) => `"${token.replaceAll('"', '""')}"`)
+        .join(' ');
+}
+function levenshtein(a, b) {
+    const previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+    const current = Array(b.length + 1).fill(0);
+    for (let i = 1; i <= a.length; i += 1) {
+        current[0] = i;
+        for (let j = 1; j <= b.length; j += 1) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            current[j] = Math.min(current[j - 1] + 1, previous[j] + 1, previous[j - 1] + cost);
+        }
+        previous.splice(0, previous.length, ...current);
+    }
+    return previous[b.length] ?? 0;
+}
+function parseMetadata(raw) {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)
+        ? parsed
+        : {};
+}
+export class SessionMemoryStore {
+    db;
+    insertsSinceOptimize = 0;
+    constructor(dbPath) {
+        this.db = new Database(typeof dbPath === 'string' ? dbPath : ':memory:');
+        this.db.exec('PRAGMA journal_mode = WAL');
+        this.db.exec('PRAGMA synchronous = NORMAL');
+        this.db.exec('PRAGMA mmap_size = 268435456');
+        this.db.exec('PRAGMA busy_timeout = 5000');
+        this.db.exec(SCHEMA_SQL);
+    }
+    close() {
+        this.db.close();
+    }
+    indexChunk(chunk) {
+        const createdAt = chunk.createdAt ?? new Date().toISOString();
+        const metadataJson = JSON.stringify(chunk.metadata ?? {});
+        this.db
+            .prepare(`INSERT INTO session_memory_chunks (id, source, text, metadata_json, created_at)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           source = excluded.source,
+           text = excluded.text,
+           metadata_json = excluded.metadata_json,
+           created_at = excluded.created_at`)
+            .run(chunk.id, chunk.source, chunk.text, metadataJson, createdAt);
+        this.db.prepare('DELETE FROM session_memory_chunks_fts WHERE id = ?').run(chunk.id);
+        this.db.prepare('DELETE FROM session_memory_chunks_tri WHERE id = ?').run(chunk.id);
+        this.db
+            .prepare('INSERT INTO session_memory_chunks_fts (id, source, text) VALUES (?, ?, ?)')
+            .run(chunk.id, chunk.source, chunk.text);
+        this.db
+            .prepare('INSERT INTO session_memory_chunks_tri (id, source, text) VALUES (?, ?, ?)')
+            .run(chunk.id, chunk.source, chunk.text);
+        this.insertsSinceOptimize += 1;
+        if (this.insertsSinceOptimize >= OPTIMIZE_INTERVAL) {
+            this.db.exec("INSERT INTO session_memory_chunks_fts(session_memory_chunks_fts) VALUES('optimize')");
+            this.db.exec("INSERT INTO session_memory_chunks_tri(session_memory_chunks_tri) VALUES('optimize')");
+            this.insertsSinceOptimize = 0;
+        }
+    }
+    indexChunks(chunks) {
+        const tx = this.db.transaction((items) => {
+            for (const chunk of items)
+                this.indexChunk(chunk);
+        });
+        tx(chunks);
+    }
+    search(options) {
+        const limit = options.limit ?? 5;
+        const ftsQuery = escapeFtsQuery(options.query);
+        if (!ftsQuery)
+            return [];
+        const scoped = this.searchFts('porter', ftsQuery, options.source, limit);
+        if (scoped.length > 0)
+            return scoped;
+        const trigram = this.searchFts('trigram', ftsQuery, options.source, limit);
+        if (trigram.length > 0)
+            return trigram;
+        const fuzzy = this.searchLevenshtein(options.query, options.source, limit);
+        if (fuzzy.length > 0)
+            return fuzzy;
+        return options.source ? this.search({ ...options, source: undefined }) : [];
+    }
+    count() {
+        const row = this.db
+            .prepare('SELECT COUNT(*) AS count FROM session_memory_chunks')
+            .get();
+        return row?.count ?? 0;
+    }
+    searchFts(tier, query, source, limit) {
+        const table = tier === 'porter' ? 'session_memory_chunks_fts' : 'session_memory_chunks_tri';
+        const sourceFilter = source ? 'AND c.source = ?' : '';
+        const params = source
+            ? [query, source, limit]
+            : [query, limit];
+        const rows = this.db
+            .prepare(`SELECT c.id, c.source, c.text, c.metadata_json, c.created_at, bm25(${table}) * -1 AS score
+         FROM ${table} f
+         JOIN session_memory_chunks c ON c.id = f.id
+         WHERE ${table} MATCH ? ${sourceFilter}
+         ORDER BY score DESC
+         LIMIT ?`)
+            .all(...params);
+        return rows.map((row) => this.mapResult(row, row.score, tier));
+    }
+    searchLevenshtein(query, source, limit) {
+        const rows = source
+            ? this.db
+                .prepare('SELECT id, source, text, metadata_json, created_at FROM session_memory_chunks WHERE source = ?')
+                .all(source)
+            : this.db
+                .prepare('SELECT id, source, text, metadata_json, created_at FROM session_memory_chunks')
+                .all();
+        const queryTokens = tokenize(query);
+        return rows
+            .map((row) => {
+            const textTokens = tokenize(row.text);
+            const bestDistance = Math.min(...queryTokens.map((needle) => Math.min(...textTokens.map((token) => levenshtein(needle, token)))));
+            const idfWeight = 1 + Math.log(1 + rows.length / Math.max(1, textTokens.length));
+            return { row, score: idfWeight / (1 + bestDistance) };
+        })
+            .filter((item) => Number.isFinite(item.score) && item.score > 0.15)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit)
+            .map((item) => this.mapResult(item.row, item.score, 'levenshtein'));
+    }
+    mapResult(row, score, tier) {
+        const chunk = {
+            id: row.id,
+            source: row.source,
+            text: row.text,
+            metadata: parseMetadata(row.metadata_json),
+            createdAt: row.created_at,
+        };
+        return { ...chunk, score, tier };
+    }
+}
+//# sourceMappingURL=store.js.map

package/dist/esm/session-memory/types.d.ts

@@ -0,0 +1,58 @@
+export interface SessionMemoryChunk {
+    id: string;
+    source: string;
+    text: string;
+    metadata?: Record<string, unknown>;
+    createdAt?: string;
+}
+export interface IndexedSessionMemoryChunk extends Required<Omit<SessionMemoryChunk, 'metadata'>> {
+    metadata: Record<string, unknown>;
+}
+export interface SessionMemorySearchOptions {
+    query: string;
+    source?: string;
+    limit?: number;
+}
+export interface SessionMemorySearchResult extends IndexedSessionMemoryChunk {
+    score: number;
+    tier: 'porter' | 'trigram' | 'levenshtein';
+}
+export interface SessionEventInput {
+    eventId?: string;
+    ts?: string;
+    toolName: string;
+    content: string;
+}
+export interface SessionCaptureInput {
+    repoHash: string;
+    agentId?: string;
+    sessionId?: string;
+    event: SessionEventInput;
+}
+export interface SnapshotInput {
+    repoHash: string;
+    sessionId?: string;
+    agentId?: string;
+    capMs?: number;
+}
+export interface SnapshotResult {
+    snapshotId: string;
+    sessionId: string;
+    status: 'complete' | 'partial';
+    eventCount: number;
+    content: string;
+}
+export interface RestoreInput {
+    repoHash: string;
+    query: string;
+    limit?: number;
+}
+export interface RestoredSessionEvent {
+    sessionId: string;
+    eventId: string;
+    ts: string;
+    toolName: string;
+    content: string;
+    score: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/session-memory/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/esm/symlinker/consumers.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Default consumer configurations for the symlinker.
+ *
+ * Consumers are tool-specific directories that mirror the canonical source of
+ * truth under `.agent/` via symlinks. Each consumer entry describes a single
+ * directory and the relative prefix used when creating symlinks from that
+ * directory back into `.agent/`.
+ *
+ * Primary IDEs (Claude Code, Codex, Cursor, Windsurf, OpenCode) are handled by
+ * their documented native surfaces:
+ *   - Codex skills: `.agents/skills/` (plus user/global roots), covered by
+ *     DEFAULT_UNIFIED_CONSUMERS. `.codex/agents/` is not a skill root.
+ *   - Claude Code skills: `.claude/skills/` and plugin distribution.
+ *   - Cursor / Windsurf: webpresso-localskills-distribution (localskills.sh)
+ *     plus copied rules/skills below where the tools need project files.
+ *   - OpenCode skills: `.opencode/skills/`, `.claude/skills/`, and
+ *     `.agents/skills/`. Agent-kit writes `.agents/skills/` and `.claude/skills/`
+ *     so OpenCode sees the same core capabilities without extra aliases.
+ *     Rules surface: opencode reads `AGENTS.md` directly from the repo root; no
+ *     symlinker consumer needed.
+ *
+ * The `UNIFIED_CONSUMERS` registry below describes per-IDE projection of the
+ * unified rule/skill content kinds (catalog ∪ consumer). Strategies:
+ *   - 'symlink':   create a relative symlink to the source (file or dir)
+ *   - 'copy':      copy file or recursively copy dir tree
+ *   - 'transform': run a transform function over the body and write the
+ *                  resulting bytes (used for Gemini TOML)
+ */
+import type { ContentKind, ContentRecord } from '#content/loader';
+export interface ConsumerConfig {
+    dir: string;
+    sourcePrefix: string;
+}
+export declare const DEFAULT_CONSUMERS: ConsumerConfig[];
+export declare const ALLOWED_REAL_FILES: Set<string>;
+export interface SkillsConsumerConfig {
+    linkPath: string;
+    target: string;
+}
+export declare const DEFAULT_SKILLS_CONSUMERS: SkillsConsumerConfig[];
+/**
+ * Per-skill consumer — creates one directory symlink per skill in
+ * `.agent/skills/`, instead of a single skills-root symlink. Codex documents
+ * symlinked skill folders as a supported discovery shape.
+ *
+ * Source-of-truth is `.agent/skills/<slug>/` — the consumer projection
+ * produced by `runUnifiedSync`.
+ */
+export interface PerSkillConsumerConfig {
+    dir: string;
+}
+export declare const DEFAULT_PER_SKILL_CONSUMERS: PerSkillConsumerConfig[];
+export type UnifiedStrategy = 'symlink' | 'copy' | 'transform';
+export interface UnifiedTransformInput {
+    readonly record: ContentRecord;
+    readonly targetPath: string;
+}
+export interface UnifiedConsumerConfig {
+    /** Human-readable id (used in logs and tests). */
+    readonly id: string;
+    /** Repo-root-relative directory that receives projected content. */
+    readonly dir: string;
+    /** Which content kind this consumer accepts (one entry per kind). */
+    readonly acceptsKind: ContentKind;
+    /** Projection strategy. */
+    readonly strategy: UnifiedStrategy;
+    /**
+     * Output extension for rules (single-file). Default '.md'. Cursor uses
+     * '.mdc'; Gemini uses '.toml'.
+     */
+    readonly ruleExtension?: string;
+    /**
+     * Optional transform applied when strategy is 'transform'. Receives the
+     * record body and returns the bytes to write at targetPath.
+     */
+    readonly transform?: (input: UnifiedTransformInput) => string;
+}
+/**
+ * Default-output filename for a rule record under a given consumer.
+ * Pure helper — no I/O — so tests can assert it directly.
+ */
+export declare function unifiedRuleFilename(consumer: UnifiedConsumerConfig, slug: string): string;
+/**
+ * Default registry of unified consumers (rules + skills projection).
+ *
+ * Per the Wave 2 task plan:
+ *   - `.agent/{rules,skills}/` (working dir): symlink, accepts rule + skill
+ *   - `.cursor/rules/`: copy, accepts rule (Cursor follows symlinks unreliably)
+ *   - `.windsurf/skills/`: copy, accepts skill
+ *   - `.claude/rules/`: symlink, accepts rule
+ *   - `.claude/skills/`: symlink, accepts skill
+ *   - `.agents/skills/`: symlink, accepts skill (Codex/OpenCode portable root)
+ * Codex intentionally has no `.codex/agents/` consumer. Official Codex skill
+ * discovery is `.agents/skills/`, `~/.agents/skills`, and `/etc/codex/skills`.
+ */
+export declare const DEFAULT_UNIFIED_CONSUMERS: readonly UnifiedConsumerConfig[];
+//# sourceMappingURL=consumers.d.ts.map

package/dist/esm/symlinker/consumers.js

@@ -0,0 +1,87 @@
+/**
+ * Default consumer configurations for the symlinker.
+ *
+ * Consumers are tool-specific directories that mirror the canonical source of
+ * truth under `.agent/` via symlinks. Each consumer entry describes a single
+ * directory and the relative prefix used when creating symlinks from that
+ * directory back into `.agent/`.
+ *
+ * Primary IDEs (Claude Code, Codex, Cursor, Windsurf, OpenCode) are handled by
+ * their documented native surfaces:
+ *   - Codex skills: `.agents/skills/` (plus user/global roots), covered by
+ *     DEFAULT_UNIFIED_CONSUMERS. `.codex/agents/` is not a skill root.
+ *   - Claude Code skills: `.claude/skills/` and plugin distribution.
+ *   - Cursor / Windsurf: webpresso-localskills-distribution (localskills.sh)
+ *     plus copied rules/skills below where the tools need project files.
+ *   - OpenCode skills: `.opencode/skills/`, `.claude/skills/`, and
+ *     `.agents/skills/`. Agent-kit writes `.agents/skills/` and `.claude/skills/`
+ *     so OpenCode sees the same core capabilities without extra aliases.
+ *     Rules surface: opencode reads `AGENTS.md` directly from the repo root; no
+ *     symlinker consumer needed.
+ *
+ * The `UNIFIED_CONSUMERS` registry below describes per-IDE projection of the
+ * unified rule/skill content kinds (catalog ∪ consumer). Strategies:
+ *   - 'symlink':   create a relative symlink to the source (file or dir)
+ *   - 'copy':      copy file or recursively copy dir tree
+ *   - 'transform': run a transform function over the body and write the
+ *                  resulting bytes (used for Gemini TOML)
+ */
+export const DEFAULT_CONSUMERS = [
+// Primary IDEs removed — distributed via native channels (plugin / localskills.sh).
+// Intentionally NOT mapped: `.codex/prompts/`. OpenAI deprecated Codex
+// custom prompts in favour of skills, and the surface was home-only
+// (~/.codex/prompts/) even before deprecation — project-local
+// `.codex/prompts/` is never discovered by Codex.
+// See https://developers.openai.com/codex/custom-prompts
+];
+export const ALLOWED_REAL_FILES = new Set(['README.md', '.markdownlint.json']);
+export const DEFAULT_SKILLS_CONSUMERS = [
+// .claude/skills removed — covered by the Claude Code plugin (primary channel).
+];
+export const DEFAULT_PER_SKILL_CONSUMERS = [
+    {
+        dir: '.agents/skills',
+    },
+];
+/**
+ * Default-output filename for a rule record under a given consumer.
+ * Pure helper — no I/O — so tests can assert it directly.
+ */
+export function unifiedRuleFilename(consumer, slug) {
+    const ext = consumer.ruleExtension ?? '.md';
+    return `${slug}${ext}`;
+}
+/**
+ * Default registry of unified consumers (rules + skills projection).
+ *
+ * Per the Wave 2 task plan:
+ *   - `.agent/{rules,skills}/` (working dir): symlink, accepts rule + skill
+ *   - `.cursor/rules/`: copy, accepts rule (Cursor follows symlinks unreliably)
+ *   - `.windsurf/skills/`: copy, accepts skill
+ *   - `.claude/rules/`: symlink, accepts rule
+ *   - `.claude/skills/`: symlink, accepts skill
+ *   - `.agents/skills/`: symlink, accepts skill (Codex/OpenCode portable root)
+ * Codex intentionally has no `.codex/agents/` consumer. Official Codex skill
+ * discovery is `.agents/skills/`, `~/.agents/skills`, and `/etc/codex/skills`.
+ */
+export const DEFAULT_UNIFIED_CONSUMERS = [
+    // Working dir: split into rules/ and skills/ siblings under .agent/
+    { id: 'agent-rules', dir: '.agent/rules', acceptsKind: 'rule', strategy: 'symlink' },
+    { id: 'agent-skills', dir: '.agent/skills', acceptsKind: 'skill', strategy: 'symlink' },
+    // Cursor: rules only, copy, .mdc extension
+    {
+        id: 'cursor-rules',
+        dir: '.cursor/rules',
+        acceptsKind: 'rule',
+        strategy: 'copy',
+        ruleExtension: '.mdc',
+    },
+    // Windsurf: skills only, copy
+    { id: 'windsurf-skills', dir: '.windsurf/skills', acceptsKind: 'skill', strategy: 'copy' },
+    // Claude: rules are scaffolded to .claude/rules; skills remain under .claude/skills.
+    { id: 'claude-rules', dir: '.claude/rules', acceptsKind: 'rule', strategy: 'symlink' },
+    { id: 'claude-skills', dir: '.claude/skills', acceptsKind: 'skill', strategy: 'symlink' },
+    // Portable Codex/OpenCode skill root.
+    { id: 'portable-skills', dir: '.agents/skills', acceptsKind: 'skill', strategy: 'symlink' },
+];
+//# sourceMappingURL=consumers.js.map

package/dist/esm/symlinker/frontmatter.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Minimal YAML frontmatter parser used by the Gemini TOML writer.
+ *
+ * Intentionally hand-rolled rather than depending on `gray-matter` because
+ * `webpresso/symlinker` must stay runtime-dependency-free at the
+ * leaf level — the symlinker ships inside the `wp` CLI and is called from
+ * hot paths where pulling in a YAML engine for a single `description:` line
+ * is overkill.
+ */
+export interface ParsedFrontmatter {
+    description: string;
+    body: string;
+}
+export declare function parseMarkdownFrontmatter(content: string): ParsedFrontmatter;
+//# sourceMappingURL=frontmatter.d.ts.map

package/dist/esm/symlinker/frontmatter.js

@@ -0,0 +1,20 @@
+/**
+ * Minimal YAML frontmatter parser used by the Gemini TOML writer.
+ *
+ * Intentionally hand-rolled rather than depending on `gray-matter` because
+ * `webpresso/symlinker` must stay runtime-dependency-free at the
+ * leaf level — the symlinker ships inside the `wp` CLI and is called from
+ * hot paths where pulling in a YAML engine for a single `description:` line
+ * is overkill.
+ */
+export function parseMarkdownFrontmatter(content) {
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!fmMatch)
+        return { description: '', body: content };
+    const frontmatter = fmMatch[1] ?? '';
+    const body = (fmMatch[2] ?? '').trim();
+    const descMatch = frontmatter.match(/description:\s*['"]?(.*?)['"]?\s*$/m);
+    const description = descMatch?.[1] ?? '';
+    return { description, body };
+}
+//# sourceMappingURL=frontmatter.js.map

package/dist/esm/symlinker/index.d.ts

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+/**
+ * Audit & Auto-Fix: Agent Command/Workflow Symlinks
+ *
+ * Ensures all consumer directories (e.g. .claude/commands) use symlinks
+ * pointing to `.agent/` source files, keeps skill directories as single
+ * directory-symlinks, and regenerates `.gemini/commands/*.toml` from
+ * markdown sources.
+ *
+ * Auto-fixes:
+ * - Replaces real files with symlinks to .agent/ source
+ * - Removes broken symlinks and recreates them
+ * - Removes stale mirrored files when the .agent/ source no longer exists
+ * - Creates missing symlinks for all .agent/ entries
+ * - Removes symlinks pointing outside .agent/
+ *
+ * Usage:
+ *   wp symlink sync            # Phase 2 — wires to syncAll
+ *   node dist/symlinker/index  # direct invocation from built output
+ */
+import { ALLOWED_REAL_FILES, type ConsumerConfig, DEFAULT_CONSUMERS, DEFAULT_PER_SKILL_CONSUMERS, DEFAULT_SKILLS_CONSUMERS, type PerSkillConsumerConfig, type SkillsConsumerConfig } from './consumers.js';
+export { ALLOWED_REAL_FILES, type ConsumerConfig, DEFAULT_CONSUMERS, DEFAULT_PER_SKILL_CONSUMERS, type PerSkillConsumerConfig, DEFAULT_SKILLS_CONSUMERS, type SkillsConsumerConfig, };
+export declare function isAgentOrConsumerFile(file: string): boolean;
+export declare function getAgentSources(repoRoot: string): Map<string, string>;
+export declare function syncSkillsConsumer(repoRoot: string, config: SkillsConsumerConfig): number;
+export declare function syncSkills(repoRoot: string, consumers?: SkillsConsumerConfig[]): number;
+export interface SyncSkillFanoutResult {
+    readonly wrote: number;
+}
+/**
+ * Directory-level skill projection from `.agent/skills/<slug>/` into a
+ * per-IDE consumer dir (e.g. `.agents/skills/<slug>`). Codex documents support
+ * for symlinked skill folders; file-level `SKILL.md` symlinks inside real
+ * folders are not a documented discovery shape and can be skipped by hosts.
+ *
+ * Source-of-truth: `.agent/skills/<slug>/` (the consumer projection
+ * produced by `runUnifiedSync` + scaffolders). NOT `node_modules/.../skills/`
+ * (the legacy `sourceRootDir` semantic was dropped — the bug class was
+ * an asymmetric fallback where listing succeeded against `.agent/skills/`
+ * but symlink targets pointed at the missing `node_modules/.../skills/`).
+ *
+ * Contract: `.agents/skills/<slug>` is an webpresso-owned generated symlink.
+ * Top-level entries that do not correspond to a skill in `.agent/skills/` are
+ * removed recursively. Real directories for expected slugs are also replaced
+ * so stale file-level projections cannot mask the official directory-symlink
+ * discovery surface.
+ *
+ * Throws (synchronously) on any file-op error so callers see fail-loud
+ * exit codes instead of `console.log('✅')` followed by broken state.
+ */
+export declare function syncSkillFanout(repoRoot: string, config: PerSkillConsumerConfig): SyncSkillFanoutResult;
+export declare function syncSkillFanouts(repoRoot: string, consumers?: PerSkillConsumerConfig[]): SyncSkillFanoutResult;
+export declare function createSymlink(repoRoot: string, consumerDir: string, file: string, symlinkTarget: string): void;
+export declare function fixExistingFile(repoRoot: string, config: ConsumerConfig, file: string, agentSources: Map<string, string>): boolean;
+export declare function createMissingSymlinks(repoRoot: string, config: ConsumerConfig, existingFiles: Set<string>, agentSources: Map<string, string>): number;
+export declare function syncConsumer(repoRoot: string, config: ConsumerConfig, agentSources: Map<string, string>): number;
+export declare function syncGeminiCommands(repoRoot: string): number;
+/**
+ * Sync repo-root AGENTS.md from canonical .agent/AGENTS.md.
+ * Returns 1 if a write occurred, 0 if already up to date.
+ */
+export declare function syncAgentsMd(repoRoot: string): number;
+/**
+ * Fan out .agent/mcp.json to canonical MCP consumer paths:
+ *   .mcp.json, .cursor/mcp.json
+ * Returns the number of files written/updated.
+ */
+export declare function syncMcpJson(repoRoot: string): number;
+export declare function syncAll(repoRoot: string, consumers?: ConsumerConfig[]): number;
+/**
+ * Import an existing IDE rule file into the canonical .agent/ directory.
+ *
+ * Supported sources: .cursorrules, CLAUDE.md, .github/copilot-instructions.md
+ *
+ * The source file is copied to .agent/AGENTS.md (if it does not already
+ * exist), leaving the original in place so that a subsequent `wp symlink sync`
+ * can fan it back out.  Returns the destination path on success, or null when
+ * the source file does not exist.
+ */
+export declare function importAgentFile(repoRoot: string, fromPath: string): {
+    source: string;
+    dest: string;
+} | null;
+//# sourceMappingURL=index.d.ts.map