dorfl 0.0.0 → 0.1.0

package/dist/prd-to-spec.d.ts

@@ -0,0 +1,315 @@
+/**
+ * The **`dorfl prd-to-spec` migration ENGINE** (spec
+ * `prd-to-spec-vocabulary-cutover-and-migration-command`, ADR
+ * `methodology-and-skills.md` §7e, user stories 4-9).
+ *
+ * This is the reusable, verb-agnostic core the thin `dorfl prd-to-spec` CLI
+ * shell drives. It migrates a repo's `work/` DATA + config + inert git refs from
+ * the legacy `prd` vocabulary to `spec`, AFTER dorfl's CODE + CONTRACT already
+ * speak `spec` (the source-part cutover — batches 1-5 + the contract task — is a
+ * hard prerequisite; this command reads the new `work-layout.ts` folder names
+ * and reuses the leak-scan proof).
+ *
+ * # Decision B — self-contained
+ *
+ * `runPrdToSpec` does three things IN ORDER (ADR §7e):
+ *
+ *   1. **Quiescence check** (refuse loudly): the tree is clean AND no per-item
+ *      lock is held AND no in-progress `work/prd-*`/`work/spec-*` branch carries
+ *      unlanded work. On failure it NAMES the offender and does nothing (1a).
+ *   2. **Setup contract re-sync FIRST:** copy the package's canonical
+ *      `work/protocol/*` docs (the new `spec` contract) into the target repo and
+ *      bump `work/protocol/VERSION` — the deterministic slice of what the `setup`
+ *      SKILL does, so the migrated repo picks up the new contract in one command.
+ *   3. **Four-layer DATA migration** (deterministic — done-items ARE converted):
+ *      (a) FOLDERS `work/prds/{proposed,ready,tasked,dropped}/ → work/specs/…`
+ *      via `git mv`; (b) FRONTMATTER/body `prd: → spec:` + inert path/token refs
+ *      across ALL items INCLUDING `work/tasks/done/` and `work/specs/tasked/`;
+ *      (c) CONFIG `.dorfl.json` (`prdsLandIn → specsLandIn`, keep-case);
+ *      (d) LIVE GIT REFS (inert lock-refs `refs/dorfl/lock/prd-<slug>` and
+ *      work-branches `work/prd-<slug>` — the quiescence gate guarantees none are
+ *      held/in-flight, so this renames only INERT refs).
+ *
+ * `--dry-run` reports exactly what each layer WOULD do, touching nothing.
+ * A second run on an already-migrated repo is a no-op (idempotent): each layer
+ * skips what is already in the `spec` shape.
+ *
+ * # Reusable-by-construction (user story 9)
+ *
+ * The layers are exported as INDEPENDENT pieces ({@link checkQuiescence},
+ * {@link resyncProtocol}, {@link migrateFolders}, {@link migrateItemContent},
+ * {@link migrateConfig}, {@link migrateRefs}, {@link keepCaseReplace},
+ * {@link scanForLeaks}) so a FUTURE vocabulary cutover reuses the STRUCTURE
+ * rather than re-deriving it — even though the verb itself stays purpose-named
+ * `prd-to-spec` (ADR §7e: no general `migrate <from> <to>`). The one place the
+ * `prd`/`spec` tokens are pinned is {@link MIGRATION}: a future cutover supplies
+ * a different {@link VocabularyMigration} and the same engine runs.
+ *
+ * # TOOLING decision — bespoke keep-case sweep, not `change-case`/`change-name`
+ *
+ * The parent spec's "Rename TOOLING" note asks to evaluate npm `change-case` /
+ * `change-name` for the keep-case sweep. Both were evaluated and DECLINED:
+ * `change-case` is a case CONVERTER (`camelCase ↔ snake_case`), not a
+ * keep-case find/replace of a substring across its case variants, and
+ * `change-name` renames FILES. The tokens this DATA migration rewrites are a
+ * small FIXED set (`prd`/`Prd`/`PRD` → `spec`/`Spec`/`SPEC`, plus the exact keys
+ * `prdsLandIn`, path prefixes `work/prds/`, `prd-`), so a dependency-free
+ * {@link keepCaseReplace} (3 case variants) is simpler, has no false-positive
+ * surface a generic tool would add, and keeps this package at its single runtime
+ * dependency. The forward+reverse {@link scanForLeaks} is the PROOF the sweep is
+ * complete regardless of the tool, so the bespoke choice carries no risk the
+ * gate would not catch. (Recorded here per the task's "record the choice"
+ * criterion — a JSDoc at the choice site.)
+ */
+/**
+ * A single vocabulary cutover the engine enacts: the retired word `from` (all
+ * three case variants) → the new word `to`. The `prd → spec` migration pins
+ * {@link MIGRATION}; a future cutover supplies a different value and reuses the
+ * same engine (user story 9). `configKeys` are the exact `.dorfl.json` keys that
+ * carry the `from` word (their VALUES are preserved — only the key renames).
+ */
+export interface VocabularyMigration {
+    /** The retired word, lower-case (e.g. `'prd'`). */
+    from: string;
+    /** The new word, lower-case (e.g. `'spec'`). */
+    to: string;
+    /** The retired plural folder segment under `work/` (e.g. `'prds'`). */
+    fromFolder: string;
+    /** The new plural folder segment under `work/` (e.g. `'specs'`). */
+    toFolder: string;
+    /** Exact config KEY renames (value preserved), e.g. `prdsLandIn → specsLandIn`. */
+    configKeys: ReadonlyArray<{
+        from: string;
+        to: string;
+    }>;
+}
+/** The `prd → spec` cutover this verb enacts (ADR §7e). */
+export declare const MIGRATION: VocabularyMigration;
+/**
+ * The FULL set of protocol docs `setup` propagates into a repo's
+ * `work/protocol/`. The re-sync copies EACH from the package's canonical source
+ * (via {@link resolveProtocolDoc}) so the migrated repo carries the new `spec`
+ * contract. Kept in lockstep with `skills/setup/protocol/` (the source of truth)
+ * and the `vendor-protocol` build step (which vendors these into `dist/protocol/`
+ * so the published CLI is self-contained).
+ */
+export declare const PROTOCOL_DOCS: readonly string[];
+/**
+ * Keep-case replace EVERY occurrence of `from` with `to` across the three case
+ * variants — lower (`prd → spec`), Capitalised (`Prd → Spec`), and UPPER
+ * (`PRD → SPEC`) — preserving the shape of each hit. Deliberately does a plain
+ * substring replace (no word boundary) so it rewrites `prd` inside identifiers
+ * like `prdsLandIn`/`work/prds/`; callers scope it to the tokens they mean to
+ * rewrite (a whole config key, a frontmatter-field line, a path). The bespoke
+ * dependency-free sweep the tooling JSDoc justifies over `change-case`.
+ */
+export declare function keepCaseReplace(text: string, from: string, to: string): string;
+/** Why the repo is NOT quiescent (the FIRST offending clause, in check order). */
+export interface QuiescenceViolation {
+    kind: 'dirty-tree' | 'held-lock' | 'in-progress-branch';
+    /** The offender, NAMED (a lock entry, a branch ref, or dirty-file paths). */
+    offender: string;
+}
+/**
+ * Is the repo QUIESCENT enough to migrate (ADR §7e, 1a)? Refuse if ANY of:
+ *   - the working tree is DIRTY (uncommitted/untracked changes), OR
+ *   - a per-item LOCK ref is held (`refs/dorfl/lock/*`), OR
+ *   - an in-progress `work/<from>-*`/`work/<to>-*` work-branch exists (a branch
+ *     that is NOT merged into the current tip = unlanded work in flight).
+ *
+ * Returns the FIRST violation (dirty tree dominates, then locks, then branches),
+ * naming the offender, or `undefined` when quiescent. Read-only: it inspects the
+ * LOCAL repo's refs + status (the fixture/downstream case where the migration
+ * runs in-place). The quiescence gate is what makes layer (d) safe: with no held
+ * lock and no in-flight branch, only INERT refs remain to rename.
+ */
+export declare function checkQuiescence(repoPath: string, migration?: VocabularyMigration, env?: NodeJS.ProcessEnv | undefined): QuiescenceViolation | undefined;
+/** One protocol doc the re-sync copied (or WOULD copy under `--dry-run`). */
+export interface ResyncedDoc {
+    /** The doc basename (e.g. `'WORK-CONTRACT.md'`). */
+    name: string;
+    /** Repo-relative destination (`work/protocol/<name>`). */
+    dest: string;
+    /** True when the target already had byte-identical content (a no-op copy). */
+    unchanged: boolean;
+}
+/** What the protocol re-sync did (or would do). */
+export interface ResyncResult {
+    docs: ResyncedDoc[];
+    /** Repo-relative `work/protocol/VERSION` path (written unless dry-run). */
+    versionPath: string;
+}
+/**
+ * Re-sync the target repo's `work/protocol/*` from the package's canonical
+ * source (the deterministic part of the `setup` skill — copy the docs verbatim +
+ * bump `VERSION`). Resolves each doc's SOURCE via {@link resolveProtocolDoc} with
+ * NO `cwd`, so it reads the package-vendored (`dist/protocol/`) or dev-source
+ * (`skills/setup/protocol/`) copy — NEVER the target repo's own (old) copy. This
+ * is how the migrated repo picks up the new `spec` contract before its data is
+ * converted. Idempotent: a doc already byte-identical is reported `unchanged`.
+ *
+ * `dryRun` reports what WOULD be copied without writing.
+ */
+export declare function resyncProtocol(repoPath: string, options?: {
+    dryRun?: boolean;
+}): ResyncResult;
+/** One folder the move relocated (or would relocate). */
+export interface FolderMove {
+    from: string;
+    to: string;
+}
+/**
+ * Move `work/<from>s/{proposed,ready,tasked,dropped}/ → work/<to>s/…`. The
+ * DESTINATION spellings match `work-layout.ts`'s post-cutover folder names in
+ * lockstep — this layer moves the DATA folders the CODE already renamed.
+ *
+ * A sub-folder with TRACKED files is `git mv`'d (renames preserve history); a
+ * sub-folder that exists on disk but has NO tracked files (an empty staging dir
+ * `setup` created — git never tracks empty dirs, so `git mv` would fatal on it)
+ * is instead removed with a plain `rmdir` so no stray `work/<from>s/` folder is
+ * left to leak (the empty dir carries no data). Only folders that EXIST are
+ * touched (an absent sub-folder is skipped), so it is idempotent AND
+ * partial-repo safe: a second run finds `work/<from>s/*` gone and does nothing.
+ * `dryRun` reports the moves without touching git or the filesystem.
+ */
+export declare function migrateFolders(repoPath: string, migration?: VocabularyMigration, options?: {
+    dryRun?: boolean;
+}): FolderMove[];
+/** One item file whose content the rewrite changed (or would change). */
+export interface ContentRewrite {
+    /** Repo-relative path of the item file. */
+    path: string;
+}
+/**
+ * Rewrite the retired word in ONE item's text, SCOPED to genuine STRUCTURAL
+ * refs so it never corrupts prose or an immutable provenance SLUG (a landed
+ * item's `slug: prd-to-spec-…` must survive verbatim — a slug can never be
+ * renamed):
+ *
+ *   - the `prd:` frontmatter KEY at line start (`prdAfter:` too), NOT a `prd`
+ *     inside a value/slug;
+ *   - `work/prds/…` folder paths and a bare `prds/` folder segment;
+ *   - `work/prd-<slug>` branch refs (the `work/` prefix makes it unambiguous —
+ *     a bare `prd-<slug>` is NOT rewritten because it is indistinguishable from
+ *     a provenance slug fragment; a genuine bare lock entry lives on a git ref,
+ *     which {@link migrateRefs} handles, not in an item body);
+ *   - `prd:<slug>` CLI-arg tokens (a `prd:` at a non-word boundary followed by a
+ *     slug char), NOT a `prd:` embedded in a longer word.
+ *
+ * Returns the new text (unchanged when nothing matched). PURE — no IO — so it is
+ * trivially testable and the caller decides whether to write. Exported for reuse
+ * + the fixture test's determinism assertion.
+ */
+export declare function migrateItemContent(text: string, migration?: VocabularyMigration): string;
+/**
+ * Rewrite the retired word across EVERY item in the data folders (incl.
+ * `done/`/`tasked/` — determinism). Writes each changed file in place (unless
+ * `dryRun`), returning the list of files that changed. Idempotent: a file
+ * already in the `spec` shape produces identical text and is not listed.
+ */
+export declare function migrateAllItemContent(repoPath: string, migration?: VocabularyMigration, options?: {
+    dryRun?: boolean;
+}): ContentRewrite[];
+/** One config key the rewrite renamed (or would rename). */
+export interface ConfigRewrite {
+    from: string;
+    to: string;
+}
+/**
+ * Rewrite the retired config KEYS in `.dorfl.json` (`prdsLandIn → specsLandIn`),
+ * preserving each key's VALUE and the file's surrounding formatting — a TEXTUAL
+ * key rename on the raw JSON, NOT a parse+reserialise (which would drop unknown
+ * keys / reflow the file). Only renames a key that is actually present, so it is
+ * idempotent (a config already on `specsLandIn` changes nothing) and safe on a
+ * repo with no `.dorfl.json`. Returns the keys renamed. `dryRun` reports without
+ * writing.
+ */
+export declare function migrateConfig(repoPath: string, migration?: VocabularyMigration, options?: {
+    dryRun?: boolean;
+}): ConfigRewrite[];
+/** One git ref the rename relocated (or would relocate). */
+export interface RefRename {
+    from: string;
+    to: string;
+}
+/**
+ * Rename INERT local git refs carrying the retired word: per-item lock refs
+ * `refs/dorfl/lock/<from>-<slug>` → `…/<to>-<slug>` and work-branches
+ * `refs/heads/work/<from>-<slug>` → `…/work/<to>-<slug>`. The {@link
+ * checkQuiescence} gate guarantees NO lock is held and NO in-flight branch
+ * exists, so every ref reaching here is inert (a leftover created before the
+ * cutover) and a plain rename is safe. Uses `git update-ref` for lock refs (they
+ * are not branches) and `git branch -m` for work-branches. Idempotent: a ref
+ * already on the `<to>-` spelling is left alone; `dryRun` reports without
+ * touching refs.
+ */
+export declare function migrateRefs(repoPath: string, migration?: VocabularyMigration, options?: {
+    dryRun?: boolean;
+    env?: NodeJS.ProcessEnv;
+}): RefRename[];
+/** One leak the data-tree scan found (a survivor of the retired word). */
+export interface DataLeak {
+    /** Repo-relative file (or ref) the leak lives in. */
+    where: string;
+    /** The offending token/line. */
+    token: string;
+    /** Which lens flagged it. */
+    lens: 'forward' | 'reverse';
+    /** A one-line explanation. */
+    why: string;
+}
+/**
+ * The DATA-tree forward+reverse leak scan — the acceptance GATE for the
+ * command's OUTPUT (ADR §7e: the leak scan is exhaustive-by-construction). This
+ * is the DATA analogue of the source-part `prd-to-spec-leak-scan.test.ts`
+ * (which scans `src/`/`skills/`/`docs/`): here it walks the CONVERTED `work/`
+ * tree + `.dorfl.json` + the git refs.
+ *
+ *   - **FORWARD:** fails on any surviving retired word (`prd`/`Prd`/`PRD`) in a
+ *     data STRUCTURE position — a frontmatter `prd:` KEY, a `work/prds/…` folder
+ *     path, a `work/prd-<slug>` branch ref, a `prd-<slug>` lock entry, a config
+ *     key `prdsLandIn`, or a `prd:<slug>` token. It deliberately IGNORES the
+ *     retired word in running PROSE (a body sentence, an immutable provenance
+ *     slug like `prd-to-spec-…`) — those are the artifact word in narrative, not
+ *     a dangling structural ref, exactly as the source-part scan's option-A cut.
+ *   - **REVERSE:** fails on genuine English CORRUPTED by a blind keep-case sweep
+ *     (`espec…`→`esspec…`-style mangles) — the guard that `spec`'s English
+ *     collisions were not mangled.
+ *
+ * A green scan on the converted fixture is the proof the four layers left no
+ * dangling structural `prd`. Returns every leak (empty ⇒ green).
+ */
+export declare function scanForLeaks(repoPath: string, migration?: VocabularyMigration, env?: NodeJS.ProcessEnv | undefined): DataLeak[];
+/** Options for {@link runPrdToSpec}. */
+export interface PrdToSpecOptions {
+    /** The repo working-tree root to migrate (the in-place downstream/fixture). */
+    repoPath: string;
+    /** Report what WOULD change across all layers, touching nothing. */
+    dryRun?: boolean;
+    /** The vocabulary cutover (defaults to the `prd → spec` {@link MIGRATION}). */
+    migration?: VocabularyMigration;
+    env?: NodeJS.ProcessEnv;
+}
+/** What the migration did (or, under dry-run, would do). */
+export interface PrdToSpecResult {
+    /** Set when the quiescence gate REFUSED — no layer ran. */
+    refused?: QuiescenceViolation;
+    /** True when this run was a dry-run (nothing was written). */
+    dryRun: boolean;
+    resync?: ResyncResult;
+    folderMoves: FolderMove[];
+    contentRewrites: ContentRewrite[];
+    configRewrites: ConfigRewrite[];
+    refRenames: RefRename[];
+    /** Leaks found by the post-migration scan (empty ⇒ green). Skipped on refuse. */
+    leaks: DataLeak[];
+}
+/**
+ * Run the self-contained `prd → spec` migration end-to-end (ADR §7e, decision
+ * B): quiescence gate → setup re-sync → four-layer data migration → leak scan.
+ * On a quiescence violation it REFUSES (returns `{refused}`, runs no layer). The
+ * thin `dorfl prd-to-spec` CLI shell formats this result; the fixture test
+ * asserts each field. `dryRun` threads through every layer.
+ */
+export declare function runPrdToSpec(options: PrdToSpecOptions): PrdToSpecResult;
+//# sourceMappingURL=prd-to-spec.d.ts.map

package/dist/prd-to-spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prd-to-spec.d.ts","sourceRoot":"","sources":["../src/prd-to-spec.ts"],"names":[],"mappings":"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"}