@timekast/factory 0.1.0 → 0.1.1

package/dist/commands/new.js

@@ -1,16 +1,16 @@
 /**
  * `factory new <Name>` — bootstrap a brand-new derived project (design §6.1).
  *
- * Flow: validate name → preflight (gh) → refuse if a repo already exists →
- * confirm if the cwd is non-empty → choose profile (full | core) → create the
- * GitHub repo → download the profile tarball → unpack (no Factory `.git/`) →
- * `git init` → rename `package.json.name` → write the initial lockfile →
- * inject the `factory:update` script.
+ * Flow: validate name → refuse if inside a repo → refuse if `./<name>/` exists
+ * and is non-empty → preflight (gh) → choose profile (full | core) → create the
+ * GitHub repo → download the profile tarball → unpack into `./<name>/` (no
+ * Factory `.git/`) → `git init` → rename `package.json.name` → write the initial
+ * lockfile → inject `factory:update` → initial commit (non-fatal if no git id).
  *
  * Expected failures throw `CLIError`; the top-level handler prints the message
  * and exits with the carried code.
  */
-import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { execa } from 'execa';
@@ -40,18 +40,6 @@ async function promptProfile() {
     }
     return choice;
 }
-/** Confirm continuing into a non-empty (but non-repo) directory. */
-async function confirmNonEmptyDir() {
-    const { proceed } = await prompts({
-        type: 'confirm',
-        name: 'proceed',
-        message: 'El directorio actual no está vacío. ¿Deseas continuar de todos modos?',
-        initial: false,
-    });
-    if (!proceed) {
-        throw new CLIError('Operación cancelada: el directorio no está vacío.', 130);
-    }
-}
 /** Create the destination GitHub repo, surfacing gh's error cleanly. */
 async function createRepo(name) {
     try {
@@ -69,15 +57,16 @@ export async function runNew(name) {
     // 2. Refuse to run inside an existing repo (before any destructive action).
     const cwd = process.cwd();
     if (existsSync(path.join(cwd, '.git'))) {
-        throw new CLIError('ya hay un repo aquí, usa `add`');
+        throw new CLIError('estás dentro de un repo git: sal del repo para crear un proyecto nuevo, o usa `add` para sumar el cerebro a este repo.');
     }
-    // 3. Preflight: gh installed + authed + org member.
-    await runPreflight();
-    // 4. Non-empty (but non-repo) directory → confirm instead of aborting.
-    const cwdEntries = readdirSync(cwd);
-    if (cwdEntries.length > 0) {
-        await confirmNonEmptyDir();
+    // 3. Destination = ./<name>/. Validate availability BEFORE any network call so
+    //    a name clash never leaves an orphan GitHub repo (B3).
+    const destDir = path.join(cwd, validName);
+    if (existsSync(destDir) && readdirSync(destDir).length > 0) {
+        throw new CLIError(`El directorio \`${validName}\` ya existe y no está vacío.`);
     }
+    // 4. Preflight: gh installed + authed + org member.
+    await runPreflight();
     // 5. Choose profile.
     const profile = await promptProfile();
     // 6. Network: create the repo.
@@ -102,12 +91,13 @@ export async function runNew(name) {
         const tarball = await downloadProfileTarball(profile, tmpDir);
         // Extract + validate the embedded manifest before touching the destination.
         const { stagedDir, manifestRaw } = await stageProfileTarball(tarball, tmpDir);
-        // Move contents into cwd (without the Factory's git lineage).
-        moveContentsInto(stagedDir, cwd);
+        // Move contents into ./<name>/ (without the Factory's git lineage).
+        mkdirSync(destDir, { recursive: true });
+        moveContentsInto(stagedDir, destDir);
         // git init (own lineage).
-        await execa('git', ['init'], { cwd });
+        await execa('git', ['init'], { cwd: destDir });
         // Rename package.json.name + inject factory:update (surgical, §7.4).
-        const pkgPath = path.join(cwd, 'package.json');
+        const pkgPath = path.join(destDir, 'package.json');
         if (existsSync(pkgPath)) {
             const { content, scriptAlreadyPresent } = applyPackageJsonEdits(readFileSync(pkgPath, 'utf8'), validName);
             writeFileSync(pkgPath, content, 'utf8');
@@ -117,7 +107,19 @@ export async function runNew(name) {
         }
         // Write the initial lockfile = the tarball's embedded manifest verbatim
         // (no hash recompute — that's DIST-005).
-        writeInitialLockfile(cwd, manifestRaw);
+        writeInitialLockfile(destDir, manifestRaw);
+        // Initial commit (H3). Non-fatal: a fresh machine may lack git identity —
+        // the project is already usable; warn and let the dev commit by hand (B2).
+        try {
+            await execa('git', ['add', '-A'], { cwd: destDir });
+            await execa('git', ['commit', '-m', 'chore: initial commit from TimeKast Factory'], {
+                cwd: destDir,
+            });
+        }
+        catch {
+            console.warn('Aviso: no se pudo crear el commit inicial (¿falta `git config --global user.email`/`user.name`?). ' +
+                'El proyecto está listo; commitea a mano cuando configures tu identidad git.');
+        }
     }
     finally {
         process.removeListener('SIGINT', onSignal);
@@ -125,4 +127,5 @@ export async function runNew(name) {
         cleanup();
     }
     console.log(`\n✔ Proyecto \`${validName}\` listo. Repo: ${FACTORY_ORG}/${validName}`);
+    console.log(`  cd ${validName}`);
 }

package/dist/commands/update.js

@@ -206,15 +206,22 @@ function warnOnScriptConflict(action, _pkgPath) {
         console.warn('Aviso: `factory:update` ya existe en package.json con otro valor; no se sobrescribió.');
     }
 }
-/** Print the deletes (design §7.6 — visible, not silent) + a one-line summary. */
+/** Print the deletes + kept-retired (design §7.6 — visible) + a one-line summary. */
 function reportSummary(diff) {
     if (diff.deleteSilent.length > 0) {
         console.log('\nArchivos retirados por el Factory en esta versión:');
         for (const e of diff.deleteSilent)
             console.log(`  Archivos retirados: ${e.path}`);
     }
-    console.log(`\n✔ update: ${diff.add.length} agregados, ${diff.overwriteSilent.length} actualizados, ` +
-        `${diff.deleteSilent.length} retirados, ${diff.conflicts.length} conflictos.`);
+    if (diff.keptRetiredLocal.length > 0) {
+        console.log('\nConservados con tus cambios — ya no los gestiona el Factory:');
+        for (const e of diff.keptRetiredLocal)
+            console.log(`  Conservado (editado localmente): ${e.path}`);
+    }
+    const unchanged = diff.unchanged.length > 0 ? ` (${diff.unchanged.length} sin cambios)` : '';
+    const kept = diff.keptRetiredLocal.length > 0 ? `, ${diff.keptRetiredLocal.length} conservados` : '';
+    console.log(`\n✔ update: ${diff.add.length} agregados, ${diff.overwriteSilent.length} actualizados${unchanged}, ` +
+        `${diff.deleteSilent.length} retirados${kept}, ${diff.conflicts.length} conflictos.`);
 }
 /**
  * Run `factory update`. Orchestrates the full flow; `deps.acquire` is the only

package/dist/lib/lockfile.js

@@ -158,22 +158,20 @@ export function writeLockfile(rootDir, lockfile) {
  * repo). This function only diffs the two manifests it is handed.
  *
  * Buckets:
- *   - add:             in newManifest, absent on disk.
- *   - overwriteSilent: in both manifests, localHash == registeredHash.
- *   - deleteSilent:    in oldLock, absent from newManifest (kit-retired).
- *   - ignoreLocal:     on disk under a tracked dir but in NO manifest → untouched.
- *                      (Populated by the caller from the disk scan; here we only
- *                      surface paths present on disk that are in neither manifest
- *                      when they were passed in `diskHashes`.)
- *   - conflicts:       localHash != registeredHash AND newHash != registeredHash.
+ *   - add:              in newManifest, absent on disk.
+ *   - overwriteSilent:  clean on disk AND the Factory changed it → rewrite silently.
+ *   - unchanged:        identical on disk, lockfile AND new manifest → no-op (not
+ *                       rewritten, not counted as "updated"). Avoids the false
+ *                       "238 updated" on a fresh, drift-free derivative.
+ *   - deleteSilent:     in oldLock, absent from newManifest, disk clean → delete.
+ *   - keptRetiredLocal: retired by the Factory but edited locally → preserve + warn
+ *                       (NOT a conflict — a retired file has no version in stagedDir).
+ *   - ignoreLocal:      on disk under a tracked dir but in NO manifest → untouched.
+ *   - conflicts:        localHash != registeredHash AND newHash != registeredHash
+ *                       AND they did not converge.
  *
- * Note on a file in newManifest, present on disk, localHash == newHash already:
- * it is treated as overwriteSilent (re-writing identical bytes is a no-op the
- * swap performs harmlessly) UNLESS localHash != registeredHash AND
- * newHash != registeredHash → then it is a conflict (the dev edited it and the
- * Factory changed it, even if they happened to converge we still surface it per
- * the design's binary rule). We special-case convergence below to avoid a
- * pointless prompt when local already equals the incoming version.
+ * Convergence (localHash == newHash) is treated as `unchanged`: the disk already
+ * holds the incoming version, so there is nothing to rewrite or prompt about.
  */
 export function diffLockfiles(oldLock, newManifest, diskHashes) {
     const oldByPath = new Map(oldLock.files.map((f) => [f.path, f]));
@@ -181,7 +179,9 @@ export function diffLockfiles(oldLock, newManifest, diskHashes) {
     const diff = {
         add: [],
         overwriteSilent: [],
+        unchanged: [],
         deleteSilent: [],
+        keptRetiredLocal: [],
         ignoreLocal: [],
         conflicts: [],
     };
@@ -198,9 +198,9 @@ export function diffLockfiles(oldLock, newManifest, diskHashes) {
         if (registeredHash === undefined) {
             // On disk but not in the old lockfile: untracked-but-present. Treat as a
             // conflict only if the disk content differs from the incoming version;
-            // otherwise it is already correct → silent.
+            // otherwise it is already correct → unchanged (no rewrite).
             if (localHash === newEntry.hash) {
-                diff.overwriteSilent.push(newEntry);
+                diff.unchanged.push(newEntry);
             }
             else {
                 diff.conflicts.push({
@@ -215,8 +215,12 @@ export function diffLockfiles(oldLock, newManifest, diskHashes) {
         const localEdited = localHash !== registeredHash;
         const factoryChanged = newEntry.hash !== registeredHash;
         if (!localEdited) {
-            // Clean kit file (matches the lockfile) → silent overwrite.
-            diff.overwriteSilent.push(newEntry);
+            // Clean kit file (matches the lockfile). Rewrite only if the Factory
+            // actually changed it; otherwise it is identical everywhere → no-op.
+            if (factoryChanged)
+                diff.overwriteSilent.push(newEntry);
+            else
+                diff.unchanged.push(newEntry);
         }
         else if (!factoryChanged) {
             // Dev edited it, Factory did NOT change it → keep the dev's version.
@@ -225,8 +229,8 @@ export function diffLockfiles(oldLock, newManifest, diskHashes) {
             diff.ignoreLocal.push(newEntry.path);
         }
         else if (localHash === newEntry.hash) {
-            // Converged: dev's edit happens to equal the new version → silent.
-            diff.overwriteSilent.push(newEntry);
+            // Converged: dev's edit happens to equal the new version → already correct.
+            diff.unchanged.push(newEntry);
         }
         else {
             // Edited locally AND changed by the Factory, diverging → conflict.
@@ -238,10 +242,19 @@ export function diffLockfiles(oldLock, newManifest, diskHashes) {
             });
         }
     }
-    // Walk the old lockfile: deleteSilent (in old, gone from new).
+    // Walk the old lockfile: a file retired from the new manifest. Respect local
+    // edits (H7) — never silently delete a tracked file the dev changed.
     for (const oldEntry of oldLock.files) {
-        if (!newByPath.has(oldEntry.path)) {
-            diff.deleteSilent.push(oldEntry);
+        if (newByPath.has(oldEntry.path))
+            continue;
+        const localHash = diskHashes.get(oldEntry.path);
+        if (localHash === undefined)
+            continue; // dev already removed it → no-op
+        if (localHash === oldEntry.hash) {
+            diff.deleteSilent.push(oldEntry); // clean → retire
+        }
+        else {
+            diff.keptRetiredLocal.push(oldEntry); // edited → preserve + warn
         }
     }
     // Any disk path present in NEITHER manifest is dev-owned → ignoreLocal.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timekast/factory",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Public, thin CLI to bootstrap and maintain TimeKast Factory derived projects.",
   "type": "module",
   "license": "UNLICENSED",