@crouton-kit/crouter 0.3.28 → 0.3.29

package/dist/core/skill-sync/claude-plugins.js

@@ -0,0 +1,71 @@
+/**
+ * Claude-plugin endpoint resolution for skill-sync.
+ *
+ * The `claude-plugin` endpoint scope addresses a skill IN PLACE at the path
+ * where Claude actually installs the owning plugin — `<installPath>/skills/<name>`
+ * — instead of forcing a copy under `~/.claude/skills/`. The install path is read
+ * from Claude's OWN registry (`~/.claude/plugins/installed_plugins.json`), keyed
+ * by the marketplace-qualified plugin key (`<plugin>@<marketplace>`), gated on the
+ * enable state in `~/.claude/settings.json` → `enabledPlugins`.
+ *
+ * This is Claude's registry, deliberately NOT crtr's plugin registry
+ * (`resolver.ts` / `findPluginByName`): the two are independent installs.
+ *
+ * Strictness (no lenient fallback): a key that is unknown, disabled, or whose
+ * recorded install path is missing on disk is a HARD error naming it.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { usage } from '../errors.js';
+function claudeDir() {
+    return join(homedir(), '.claude');
+}
+/**
+ * Resolve a Claude plugin's on-disk install path from its marketplace-qualified
+ * key (`<plugin>@<marketplace>`, e.g. `devcore@crouton-kit`). Throws naming the
+ * key when it is not installed, not enabled, or has no install path present on
+ * disk.
+ */
+export function resolveClaudePluginInstallPath(key) {
+    const registryPath = join(claudeDir(), 'plugins', 'installed_plugins.json');
+    if (!existsSync(registryPath)) {
+        throw usage(`skill-sync: Claude plugin registry not found at ${registryPath}`);
+    }
+    let registry;
+    try {
+        registry = JSON.parse(readFileSync(registryPath, 'utf8'));
+    }
+    catch (err) {
+        throw usage(`skill-sync: invalid ${registryPath}: ${err.message}`);
+    }
+    const entries = registry.plugins?.[key];
+    if (!Array.isArray(entries) || entries.length === 0) {
+        throw usage(`skill-sync: Claude plugin "${key}" is not installed ` +
+            `(no entry in ${registryPath})`);
+    }
+    if (!isClaudePluginEnabled(key)) {
+        throw usage(`skill-sync: Claude plugin "${key}" is installed but not enabled ` +
+            `(settings.json enabledPlugins)`);
+    }
+    const install = entries.find((e) => e.installPath && existsSync(e.installPath));
+    if (!install?.installPath) {
+        throw usage(`skill-sync: Claude plugin "${key}" has no install path present on disk`);
+    }
+    return install.installPath;
+}
+/** True iff `enabledPlugins[key] === true` in `~/.claude/settings.json`. A
+ *  missing or unparseable settings file means "not enabled" — the caller turns
+ *  that into a hard error naming the key. */
+function isClaudePluginEnabled(key) {
+    const settingsPath = join(claudeDir(), 'settings.json');
+    if (!existsSync(settingsPath))
+        return false;
+    try {
+        const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+        return settings.enabledPlugins?.[key] === true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/core/skill-sync/engine.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Reconcile engine (Phase P6) — the single, per-pair, direction-agnostic
+ * reconcile for bidirectional crtr ↔ Claude skill sync.
+ *
+ * `reconcilePair` is the ONLY reconcile routine (R-U3): there is no forward
+ * path + reverse path. Body and asset reconciliation is a symmetric 3-way merge
+ * (base = snapshot, ours = crtr, theirs = claude); frontmatter is the only
+ * asymmetric axis and all of that asymmetry lives in the translation profile
+ * (P5). The snapshot (P3) is the sole change-detector (R-U4): nothing here reads
+ * mtimes, fingerprints, or a stamp file.
+ *
+ * Strictness (R-U6): a conflict — overlapping body/asset merge, a both-sides
+ * non-equivalent frontmatter divergence, an asset deleted-on-one ∧ edited-on-the
+ * other, or a first-sync divergence with no common base — writes NOTHING for the
+ * pair, leaves both endpoints + the snapshot byte-untouched, and surfaces a
+ * git-style conflict report. There is no "best-effort" partial write and no
+ * silent side-pick.
+ *
+ * `--dry-run` (R-O1): every merge is computed and the would-be status returned,
+ * but no endpoint file, snapshot, or conflict report is touched.
+ */
+import type { Pair } from './manifest.js';
+import type { TranslationProfile } from './profile.js';
+/** The outcome of reconciling one pair. `wrote` counts endpoint files
+ *  created/updated (never deletions, never the snapshot bookkeeping). */
+export interface PairResult {
+    id: string;
+    status: 'synced' | 'conflict' | 'noop';
+    wrote: number;
+}
+export interface ReconcileOpts {
+    dryRun: boolean;
+}
+/**
+ * Reconcile a single enrolled pair (R-E2). Resolves both endpoints, loads (or
+ * seeds) the snapshot, 3-way merges body + assets and translate-and-owns the
+ * frontmatter, then either writes through cleanly to both sides or reports the
+ * conflict and skips. Never throws on a *content* conflict (that is a reported
+ * outcome); throws only on a structural/configuration error (an unresolvable
+ * endpoint, both endpoints missing) so the caller surfaces it as a hard stop.
+ */
+export declare function reconcilePair(pair: Pair, profile: TranslationProfile, opts: ReconcileOpts): PairResult;