@cellajs/cli 0.0.1

package/README.md

@@ -0,0 +1,184 @@
+# @cellajs/cli
+
+Keep your Cella-based app in sync with upstream template updates while preserving your
+customizations.
+
+## Usage
+
+From your monorepo root, run `pnpm cella` for the interactive menu, or call a service directly:
+
+```bash
+pnpm cella analyze
+pnpm cella sync --hard
+pnpm cella audit --check-overrides
+pnpm cella contributions --fork raak --json
+```
+
+## Services
+
+| Service | Description |
+|---------|-------------|
+| `analyze` | Dry run to see what would change on sync |
+| `sync` | Merge upstream changes onto a fresh branch and open a squash-merge PR into `main` |
+| `audit` | Check for outdated packages & vulnerabilities |
+| `stats` | Count files by category and workspace package |
+| `forks` * | Run normal sync inside local fork repositories |
+| `contributions` * | Pull and adopt changes from local forks |
+
+\* `forks` and `contributions` only appear in the menu when you have `forks` configured in `cella.config.ts`. These are for upstream template developers who maintain multiple downstream forks.
+
+## CLI options
+
+```bash
+pnpm cella [service] [options]
+```
+
+Per-service help: `pnpm cella <service> --help`.
+
+| Service | Useful options |
+|---------|----------------|
+| analyze | `--log`, `--list`, `--json`, `--scope <all\|risk\|protected>`, `--diff <path>`, `--open-diff <path>` |
+| sync | `--log`, `--hard`, `--unpinned`, `--track <release\|branch>` |
+| audit | `--list`, `--force`, `--check-overrides` |
+| forks | `--fork <name>`, `--log`, `--hard`, `-V, --verbose` |
+| contributions | `--fork <name>`, `--list`, `--json`, `--diff <path>` |
+| stats | `--coverage`, `-V, --verbose` |
+
+| Global flag | Description |
+|-------------|-------------|
+| `-v, --version` | Output the current version |
+| `-h, --help` | Display help message |
+
+## Configuration
+
+Sync behavior lives in `cella.config.ts` at your monorepo root (a sensible default ships with new
+apps). To deviate files or folders from the template:
+
+- **`ignored`** — files completely excluded from sync (existing and new)
+- **`pinned`** — full fork control: existing, modified, or deleted files are preserved
+
+## Upstream tracking
+
+The sync CLI tracks upstream cella one of two ways, set via `settings.upstreamTrack`:
+
+| Mode | Behavior | For |
+|------|----------|-----|
+| `release` (default) | Sync to a last cella release tag. Stable and reviewable — each bump maps to a changelog. | Most forks |
+| `branch` | Follow the bleeding-edge tip of `settings.upstreamBranch`. | cella maintainers, active development |
+
+For a one-off run that ignores the configured mode, pass `--track`:
+
+```bash
+pnpm cella sync --track branch   # follow the tip once, without editing config
+```
+
+## Sync workflow
+
+`pnpm cella sync` never commits to `main` directly. 
+
+```
+main ──▶ cella/sync/<stamp> ──(3-way merge)──▶ PR ──(squash)──▶ main
+```
+
+It runs a real git 3-way merge and leaves the result **staged** — it never auto-commits on the
+first pass. `sync` is **idempotent and two-phase**:
+
+1. **First run** cuts the branch and stages the merge, then stops so you can review (and resolve
+   any conflicts in your IDE — `git add` the resolved files).
+2. **Re-run `pnpm cella sync`** on the same branch to finish: it reconciles dependencies
+   (`pnpm install` + `pnpm check`), stages everything, commits the delta, pushes to `origin`,
+   opens a PR into `main` (via `gh`), and switches you back to `main`.
+
+When you commit, the in-progress merge state (`MERGE_HEAD`) is discarded, so the staged delta
+collapses into a **single-parent commit** (`chore: sync upstream cella <sha>`). This keeps the PR
+to one clean commit with the incremental diff — a two-parent merge commit would instead list the
+upstream branch's entire history, because the fork doesn't share pushed ancestry with upstream
+and the local `git replace` graft that makes merges incremental is never pushed. Ancestry lives
+in `refs/cella/last-sync` (and the committed `cella.manifest.json` for fresh clones), so
+`git merge-base` keeps working across throwaway branches — each is safe to delete once its PR
+lands. The three-segment name can't collide with git's ref namespacing.
+
+If conflicts remain when you re-run, `sync` lists them and stops (never starting a second cycle
+mid-merge). If `pnpm check`, the push, or `gh` fails, it degrades gracefully — reporting the
+issue and printing the remaining manual steps:
+
+```bash
+git push -u origin cella/sync/<stamp>
+gh pr create --base main --head cella/sync/<stamp> --fill
+```
+
+## Sync rules
+
+For each file, `sync` compares fork and upstream **content** (blob comparison) and resolves it
+per the table below. Unconfigured files converge on upstream; `ignored` and `pinned` let you opt
+out:
+
+| Scenario | `ignored` | `pinned` | Default |
+|----------|:---------:|:--------:|:-------:|
+| Content identical | ✅ Keep | ✅ Keep | ✅ Keep |
+| Content differs | ⏭️ Skip | ✅ Keep yours | ⬇️ Take upstream |
+| New upstream file | ⏭️ Skip | ✅ Keep (respect deletion) | ➕ Add file |
+| Deleted in upstream | ✅ Keep | ✅ Keep | 🗑️ Delete |
+| Only in your app | ✅ Keep | ✅ Keep | ✅ Keep |
+
+**Choosing an override:** `ignored` = file never syncs and is fully hidden (app-specific docs,
+assets, config you own). `pinned` = your version always wins but stays visible (files you
+customize). Unconfigured = syncs automatically. Run `pnpm cella analyze` first to preview.
+
+### Aggressive sync flags
+
+Two opt-in flags make `sync` more aggressive. Both resurface full upstream history (natural merge-base, not the last-sync point), so expect a larger diff and a post-run warning — cherry-pick deliberately. They compose (`--hard --unpinned`).
+
+| Flag | Effect |
+|------|--------|
+| `--hard` | Overwrites `drifted` files with upstream (local-only changes are replaced) |
+| `--unpinned` | Ignores `pinned` files so upstream surfaces as `behind`/`diverged`; managed files stay pinned |
+
+## Status indicators
+
+During analysis and sync, files are displayed with status indicators:
+
+| Symbol | Label | Meaning | Action |
+|:------:|-------|---------|--------|
+| ◇ | `managed` | Package/config file changed | Handled separately by cella |
+| ⨂ | `ignored` | Protected by ignored config | Excluded from sync |
+| ✓ | `identical` | Fork matches upstream | No action needed |
+| ↑ | `ahead` | Fork changed (pinned) | Protected, keeping fork |
+| ! | `drifted` | Fork changed, not protected | At risk, consider pinning |
+| ↓ | `behind` | Upstream has changes | Will sync from upstream |
+| ⇅ | `diverged` | Both sides changed | Will merge from upstream |
+| ⨀ | `pinned` | Both changed, fork wins | Protected, keeping fork |
+| + | `local` | Only in fork, never in upstream | No action needed |
+
+## Package.json sync
+
+`packageJsonSync` controls which package.json sections sync from upstream:
+
+```typescript
+packageJsonSync: ['dependencies', 'devDependencies', 'scripts']
+```
+
+**Supported keys:** `dependencies`, `devDependencies`, `peerDependencies`, `optionalDependencies`, `scripts`, `engines`, `packageManager`, `overrides`
+
+It **adds** new keys and **updates** existing ones to match upstream, but never **removes** keys
+that only exist in your fork — so extra dependencies and scripts survive each sync.
+
+## Contributions (pull from forks)
+
+Upstream can pull modifications from local forks and selectively adopt them.
+
+### Configuration
+
+List your local forks in `cella.config.ts`:
+
+```typescript
+forks: [
+  { name: 'raak', localPath: '../raak', pullBranch: 'main' },
+],
+```
+
+### Pulling contributions
+
+Run `pnpm cella contributions` (or pick **contributions** from the menu). Select one or more
+forks; cella fetches each fork's `pullBranch`, builds a clean local `contrib/<fork>` branch with
+only that fork's contributed files. Accepted files are checked out from the contrib branch and staged for review.

package/dist/config.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Sync CLI v2 - Configuration Types
+ *
+ * Simplified configuration for worktree-based merge approach.
+ */
+
+/** Valid package.json keys that can be synced */
+type PackageJsonSyncKey = 'dependencies' | 'devDependencies' | 'peerDependencies' | 'optionalDependencies' | 'scripts' | 'engines' | 'packageManager' | 'overrides' | 'pnpm';
+/**
+ * Sync settings - all configurable options for the sync CLI.
+ * Hover over each property for documentation.
+ */
+interface SyncSettings {
+    /** Upstream repository URL (e.g., 'git@github.com:cellajs/cella.git') */
+    upstreamUrl: string;
+    /**
+     * Upstream branch, used for `upstreamTrack: 'branch'` and for GitHub file links.
+     * Defaults to 'main'.
+     */
+    upstreamBranch?: string;
+    /**
+     * How to track upstream cella. Defaults to 'release'.
+     * - 'release' (default): sync to a published cella release tag (`v*`). Stable and
+     *   reviewable — each bump maps to a changelog. Uses the latest release.
+     * - 'branch': follow the bleeding-edge tip of `upstreamBranch`. For cella
+     *   maintainers and forks doing active development on top of unreleased changes.
+     */
+    upstreamTrack?: 'release' | 'branch';
+    /**
+     * Trunk branch that `pnpm cella sync` cuts the temporary branch from and that you open the
+     * squash-merge PR into. Defaults to 'main'. Cutting fresh from trunk each cycle keeps every
+     * PR limited to that cycle's upstream delta (no accumulation) and `main` linear.
+     */
+    releaseBase?: string;
+    /** Which package.json keys to sync (default: ['dependencies', 'devDependencies']) */
+    packageJsonSync?: PackageJsonSyncKey[];
+    /**
+     * Automatically run packages sync after the sync service completes.
+     * When true (default), the packages service is hidden from the menu
+     * and runs automatically as part of sync.
+     * Set to false to keep packages as a separate manual service.
+     */
+    syncWithPackages?: boolean;
+    /**
+     * How to link files in CLI output.
+     * - 'commit' (default): Link to the commit that changed the file on GitHub.
+     * - 'file': Link to the file in the repo at the upstream branch on GitHub.
+     * - 'local': Open the upstream file in VS Code from the auto-managed upstream view worktree.
+     */
+    fileLinkMode?: 'commit' | 'file' | 'local';
+}
+/**
+ * Configuration for a downstream fork repository that cella interacts with.
+ *
+ * Cella is the upstream/source-of-truth. For each fork it can:
+ * - pull contributions FROM the fork's `pullBranch` (contributions service)
+ * - run the normal temporary-branch sync flow inside the fork (forks service)
+ */
+interface ForkConfig {
+    /** Display name for the fork (also used as the contrib/<name> branch slug) */
+    name: string;
+    /** Local path to the fork repository (relative to this config or absolute) */
+    localPath: string;
+    /**
+     * Git remote URL of the fork (e.g. 'git@github.com:org/fork.git').
+     * When set, the contributions service fetches the fork's `pullBranch` from this
+     * remote (the authoritative committed ref) instead of the local clone, so the
+     * comparison no longer depends on the local checkout being up to date. The local
+     * clone is still used to read the fork's owned-folder territory when available.
+     */
+    remoteUrl?: string;
+    /** Fork branch that cella pulls contributions from (contributions service) */
+    pullBranch: string;
+}
+/**
+ * User-configurable sync options for cella.config.ts.
+ * Simplified for v2 - no long-lived sync branch or squash options.
+ */
+interface CellaCliConfig {
+    /** Core sync settings */
+    settings: SyncSettings;
+    /**
+     * File overrides for controlling sync behavior per folder/file.
+     */
+    overrides?: {
+        /**
+         * Paths the fork fully owns — never synced (existing or new).
+         * Exact paths or directory prefixes, not globs: 'bench' matches 'bench/' and
+         * everything under it, 'README.md' matches that exact file.
+         * Local territory: upstream cannot add, modify, or delete anything under these.
+         */
+        ignored?: string[];
+        /**
+         * Paths pinned to fork — fork wins on conflicts.
+         * Exact paths or directory prefixes, not globs: 'bench' matches 'bench/' and
+         * everything under it, 'README.md' matches that exact file.
+         * Non-conflicting upstream changes merge normally.
+         * If fork deleted a pinned file, deletion is respected.
+         */
+        pinned?: string[];
+    };
+    /**
+     * Downstream fork repositories that cella interacts with (for upstream template repos).
+     * When configured, the 'forks' and 'contributions' services appear in the CLI menu.
+     */
+    forks?: ForkConfig[];
+}
+/**
+ * Helper function for defining cella.config.ts with type checking.
+ */
+declare function defineConfig(config: CellaCliConfig): CellaCliConfig;
+
+export { type CellaCliConfig, type PackageJsonSyncKey, defineConfig };

package/dist/config.js

@@ -0,0 +1,44 @@
+// src/config/types.ts
+import { z } from "zod";
+function defineConfig(config) {
+  return config;
+}
+var cellaConfigSchema = z.object({
+  settings: z.object({
+    upstreamUrl: z.string().min(1),
+    upstreamBranch: z.string().min(1).optional(),
+    upstreamTrack: z.enum(["release", "branch"]).optional(),
+    releaseBase: z.string().min(1).optional(),
+    packageJsonSync: z.array(
+      z.enum([
+        "dependencies",
+        "devDependencies",
+        "peerDependencies",
+        "optionalDependencies",
+        "scripts",
+        "engines",
+        "packageManager",
+        "overrides",
+        "pnpm"
+      ])
+    ).optional(),
+    syncWithPackages: z.boolean().optional(),
+    fileLinkMode: z.enum(["commit", "file", "local"]).optional()
+  }).strict(),
+  overrides: z.object({
+    ignored: z.array(z.string()).optional(),
+    pinned: z.array(z.string()).optional()
+  }).strict().optional(),
+  forks: z.array(
+    z.object({
+      name: z.string().min(1),
+      localPath: z.string().min(1),
+      remoteUrl: z.string().optional(),
+      pullBranch: z.string().min(1)
+    }).strict()
+  ).optional()
+}).strict();
+export {
+  defineConfig
+};
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/config/types.ts"],"sourcesContent":["/**\n * Sync CLI v2 - Configuration Types\n *\n * Simplified configuration for worktree-based merge approach.\n */\n\nimport { z } from 'zod';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// PUBLIC API - for cella.config.ts\n// ─────────────────────────────────────────────────────────────────────────────\n\n/** Valid package.json keys that can be synced */\nexport type PackageJsonSyncKey =\n  | 'dependencies'\n  | 'devDependencies'\n  | 'peerDependencies'\n  | 'optionalDependencies'\n  | 'scripts'\n  | 'engines'\n  | 'packageManager'\n  | 'overrides'\n  | 'pnpm';\n\n/**\n * Sync settings - all configurable options for the sync CLI.\n * Hover over each property for documentation.\n */\nexport interface SyncSettings {\n  /** Upstream repository URL (e.g., 'git@github.com:cellajs/cella.git') */\n  upstreamUrl: string;\n\n  /**\n   * Upstream branch, used for `upstreamTrack: 'branch'` and for GitHub file links.\n   * Defaults to 'main'.\n   */\n  upstreamBranch?: string;\n\n  /**\n   * How to track upstream cella. Defaults to 'release'.\n   * - 'release' (default): sync to a published cella release tag (`v*`). Stable and\n   *   reviewable — each bump maps to a changelog. Uses the latest release.\n   * - 'branch': follow the bleeding-edge tip of `upstreamBranch`. For cella\n   *   maintainers and forks doing active development on top of unreleased changes.\n   */\n  upstreamTrack?: 'release' | 'branch';\n\n  /**\n   * Trunk branch that `pnpm cella sync` cuts the temporary branch from and that you open the\n   * squash-merge PR into. Defaults to 'main'. Cutting fresh from trunk each cycle keeps every\n   * PR limited to that cycle's upstream delta (no accumulation) and `main` linear.\n   */\n  releaseBase?: string;\n\n  /** Which package.json keys to sync (default: ['dependencies', 'devDependencies']) */\n  packageJsonSync?: PackageJsonSyncKey[];\n\n  /**\n   * Automatically run packages sync after the sync service completes.\n   * When true (default), the packages service is hidden from the menu\n   * and runs automatically as part of sync.\n   * Set to false to keep packages as a separate manual service.\n   */\n  syncWithPackages?: boolean;\n\n  /**\n   * How to link files in CLI output.\n   * - 'commit' (default): Link to the commit that changed the file on GitHub.\n   * - 'file': Link to the file in the repo at the upstream branch on GitHub.\n   * - 'local': Open the upstream file in VS Code from the auto-managed upstream view worktree.\n   */\n  fileLinkMode?: 'commit' | 'file' | 'local';\n}\n\n/**\n * Configuration for a downstream fork repository that cella interacts with.\n *\n * Cella is the upstream/source-of-truth. For each fork it can:\n * - pull contributions FROM the fork's `pullBranch` (contributions service)\n * - run the normal temporary-branch sync flow inside the fork (forks service)\n */\nexport interface ForkConfig {\n  /** Display name for the fork (also used as the contrib/<name> branch slug) */\n  name: string;\n  /** Local path to the fork repository (relative to this config or absolute) */\n  localPath: string;\n  /**\n   * Git remote URL of the fork (e.g. 'git@github.com:org/fork.git').\n   * When set, the contributions service fetches the fork's `pullBranch` from this\n   * remote (the authoritative committed ref) instead of the local clone, so the\n   * comparison no longer depends on the local checkout being up to date. The local\n   * clone is still used to read the fork's owned-folder territory when available.\n   */\n  remoteUrl?: string;\n  /** Fork branch that cella pulls contributions from (contributions service) */\n  pullBranch: string;\n}\n\n/**\n * User-configurable sync options for cella.config.ts.\n * Simplified for v2 - no long-lived sync branch or squash options.\n */\nexport interface CellaCliConfig {\n  /** Core sync settings */\n  settings: SyncSettings;\n\n  /**\n   * File overrides for controlling sync behavior per folder/file.\n   */\n  overrides?: {\n    /**\n     * Paths the fork fully owns — never synced (existing or new).\n     * Exact paths or directory prefixes, not globs: 'bench' matches 'bench/' and\n     * everything under it, 'README.md' matches that exact file.\n     * Local territory: upstream cannot add, modify, or delete anything under these.\n     */\n    ignored?: string[];\n\n    /**\n     * Paths pinned to fork — fork wins on conflicts.\n     * Exact paths or directory prefixes, not globs: 'bench' matches 'bench/' and\n     * everything under it, 'README.md' matches that exact file.\n     * Non-conflicting upstream changes merge normally.\n     * If fork deleted a pinned file, deletion is respected.\n     */\n    pinned?: string[];\n  };\n\n  /**\n   * Downstream fork repositories that cella interacts with (for upstream template repos).\n   * When configured, the 'forks' and 'contributions' services appear in the CLI menu.\n   */\n  forks?: ForkConfig[];\n}\n\n/**\n * Helper function for defining cella.config.ts with type checking.\n */\nexport function defineConfig(config: CellaCliConfig): CellaCliConfig {\n  return config;\n}\n\n/**\n * Strict runtime schema mirroring {@link CellaCliConfig}.\n *\n * The TS interfaces above stay the source of truth (and keep their hover docs for\n * config authors). This schema is what's enforced at load time: `.strict()` rejects\n * unknown keys, so a typo like `ignoredFolders` instead of `ignored` fails closed\n * instead of silently dropping sync protection (tsx does not typecheck the config).\n *\n * The `satisfies z.ZodType<CellaCliConfig>` assertion keeps schema and interface in\n * lockstep: if either drifts (a renamed/removed/mis-typed field), TypeScript errors here.\n */\nexport const cellaConfigSchema = z\n  .object({\n    settings: z\n      .object({\n        upstreamUrl: z.string().min(1),\n        upstreamBranch: z.string().min(1).optional(),\n        upstreamTrack: z.enum(['release', 'branch']).optional(),\n        releaseBase: z.string().min(1).optional(),\n        packageJsonSync: z\n          .array(\n            z.enum([\n              'dependencies',\n              'devDependencies',\n              'peerDependencies',\n              'optionalDependencies',\n              'scripts',\n              'engines',\n              'packageManager',\n              'overrides',\n              'pnpm',\n            ]),\n          )\n          .optional(),\n        syncWithPackages: z.boolean().optional(),\n        fileLinkMode: z.enum(['commit', 'file', 'local']).optional(),\n      })\n      .strict(),\n    overrides: z\n      .object({\n        ignored: z.array(z.string()).optional(),\n        pinned: z.array(z.string()).optional(),\n      })\n      .strict()\n      .optional(),\n    forks: z\n      .array(\n        z\n          .object({\n            name: z.string().min(1),\n            localPath: z.string().min(1),\n            remoteUrl: z.string().optional(),\n            pullBranch: z.string().min(1),\n          })\n          .strict(),\n      )\n      .optional(),\n  })\n  .strict() satisfies z.ZodType<CellaCliConfig>;\n\n// ─────────────────────────────────────────────────────────────────────────────\n// INTERNAL TYPES - for sync modules\n// ─────────────────────────────────────────────────────────────────────────────\n\n/** Sync services available in the CLI */\nexport type SyncService = 'analyze' | 'sync' | 'audit' | 'forks' | 'contributions' | 'stats';\n\n/** Analyze output scope for interactive and machine-readable flows */\nexport type AnalyzeScope = 'all' | 'risk' | 'protected';\n\n/** Runtime configuration with all resolved values */\nexport interface RuntimeConfig extends CellaCliConfig {\n  /** Resolved fork repository path */\n  forkPath: string;\n\n  /** Full upstream remote ref (e.g., 'cella-upstream/development') */\n  upstreamRef: string;\n\n  /** Selected sync service */\n  service: SyncService;\n\n  /** Write full file list to log file */\n  logFile: boolean;\n\n  /** Non-interactive list output (for LLM/agent usage) */\n  list: boolean;\n\n  /** Machine-readable JSON output (for tooling/agent usage) */\n  json: boolean;\n\n  /** Print the unified diff for a single contributed file, then exit (contributions; for tooling/agents) */\n  diff?: string;\n\n  /** Open a VS Code side-by-side diff for one file, then exit (analyze) */\n  openDiff?: string;\n\n  /** Scope of files returned in analyze list/json output */\n  scope?: AnalyzeScope;\n\n  /** Show verbose output */\n  verbose: boolean;\n\n  /** Pre-selected fork name (skips fork selection prompt) */\n  fork?: string;\n\n  /** Overwrite drifted files with upstream version (aggressive realignment) */\n  hard?: boolean;\n\n  /**\n   * Disable pinned entries (cella.config.ts overrides.pinned) for this sync so upstream\n   * versions surface as behind/diverged. Managed files stay pinned because cella\n   * handles them separately. Like --hard, uses the natural merge-base to resurface\n   * full upstream history.\n   */\n  unpinned?: boolean;\n\n  /**\n   * Override upstream tracking for this run (analyze/sync), ignoring `settings.upstreamTrack`.\n   * 'branch' follows the upstream branch tip (bleeding edge); 'release' uses a release tag.\n   */\n  track?: 'release' | 'branch';\n\n  /** Bypass pnpm metadata cache for fresh registry data (audit service) */\n  force?: boolean;\n\n  /** Check which pnpm.overrides are still needed (audit service) */\n  checkOverrides?: boolean;\n\n  /** Regenerate test coverage before showing the stats summary (stats service) */\n  coverage?: boolean;\n}\n\n/** File status after analysis */\nexport type FileStatus =\n  | 'identical' // No changes needed\n  | 'ahead' // Fork is ahead, protected (pinned/ignored)\n  | 'local' // Local file (never existed upstream)\n  | 'drifted' // Fork is ahead, NOT protected (at risk)\n  | 'behind' // Upstream has changes to sync\n  | 'diverged' // Both changed, will merge\n  | 'pinned' // Fork wins on conflict\n  | 'ignored' // Excluded from sync entirely\n  | 'deleted' // Fork deleted, will stay deleted\n  | 'renamed'; // Upstream renamed file\n\n/** Analyzed file with status and metadata */\nexport interface AnalyzedFile {\n  path: string;\n  status: FileStatus;\n  /** True if file is in ignored list */\n  isIgnored: boolean;\n  /** True if file is in pinned list */\n  isPinned: boolean;\n  /** True if file exists in fork */\n  existsInFork: boolean;\n  /** True if file exists in upstream */\n  existsInUpstream: boolean;\n  /** True if file has merge conflict */\n  hasConflict?: boolean;\n  /** Relative date when file was last changed (since merge-base) */\n  changedAt?: string;\n  /** Short commit hash of the last change */\n  changedCommit?: string;\n  /** For diverged files: relative date of upstream change */\n  upstreamChangedAt?: string;\n  /** For diverged files: short commit hash of the upstream change */\n  upstreamCommit?: string;\n  /** For renamed files: the original path before rename */\n  renamedFrom?: string;\n}\n\n/** Summary counts by status */\nexport interface AnalysisSummary {\n  /** Changed package/config files that are handled separately from normal sync categories */\n  managed: number;\n  identical: number;\n  ahead: number;\n  local: number;\n  drifted: number;\n  behind: number;\n  diverged: number;\n  pinned: number;\n  ignored: number;\n  deleted: number;\n  renamed: number;\n  total: number;\n}\n\n/** Merge result from merge-engine */\nexport interface MergeResult {\n  success: boolean;\n  /** Upstream branch name for file links */\n  upstreamBranch?: string;\n  /** Resolved concrete upstream ref that was merged (branch ref or release tag ref) */\n  upstreamRef?: string;\n  /** Upstream release tag synced (when tracking releases) */\n  upstreamTag?: string;\n  files: AnalyzedFile[];\n  summary: AnalysisSummary;\n  conflicts: string[];\n  /** Upstream GitHub URL base for commit links */\n  upstreamGitHubUrl?: string;\n  /** Upstream commit info */\n  upstreamCommit?: {\n    hash: string;\n    message: string;\n    date: string;\n  };\n  /** Commits included in this sync range (oldest-first when rendered) */\n  upstreamCommits?: Array<{\n    hash: string;\n    message: string;\n    date: string;\n  }>;\n  /** Files that were auto-merged by git (diverged without remaining conflicts) */\n  autoMergedFiles?: string[];\n}\n"],"mappings":";AAMA,SAAS,SAAS;AAoIX,SAAS,aAAa,QAAwC;AACnE,SAAO;AACT;AAaO,IAAM,oBAAoB,EAC9B,OAAO;AAAA,EACN,UAAU,EACP,OAAO;AAAA,IACN,aAAa,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,IAC7B,gBAAgB,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,SAAS;AAAA,IAC3C,eAAe,EAAE,KAAK,CAAC,WAAW,QAAQ,CAAC,EAAE,SAAS;AAAA,IACtD,aAAa,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,SAAS;AAAA,IACxC,iBAAiB,EACd;AAAA,MACC,EAAE,KAAK;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAC;AAAA,IACH,EACC,SAAS;AAAA,IACZ,kBAAkB,EAAE,QAAQ,EAAE,SAAS;AAAA,IACvC,cAAc,EAAE,KAAK,CAAC,UAAU,QAAQ,OAAO,CAAC,EAAE,SAAS;AAAA,EAC7D,CAAC,EACA,OAAO;AAAA,EACV,WAAW,EACR,OAAO;AAAA,IACN,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS;AAAA,IACtC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS;AAAA,EACvC,CAAC,EACA,OAAO,EACP,SAAS;AAAA,EACZ,OAAO,EACJ;AAAA,IACC,EACG,OAAO;AAAA,MACN,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,MACtB,WAAW,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,MAC3B,WAAW,EAAE,OAAO,EAAE,SAAS;AAAA,MAC/B,YAAY,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,IAC9B,CAAC,EACA,OAAO;AAAA,EACZ,EACC,SAAS;AACd,CAAC,EACA,OAAO;","names":[]}

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env tsx