@timekast/factory 0.1.5 → 0.1.7

package/dist/commands/update.js

@@ -37,7 +37,7 @@ import prompts from 'prompts';
 import { applyPlan, clearUpdateState, defaultBackupDir, hasUpdateState, readUpdateState, validateStagedManifest, writeUpdateState, } from '../lib/atomic-swap.js';
 import { CLIError } from '../lib/cli-error.js';
 import { diffLockfiles, hasLockfile, normalizeThenHash, planAutoRegister, readLockfile, writeLockfile, } from '../lib/lockfile.js';
-import { insertFactoryUpdateScript, pruneFactoryMeta } from '../lib/package-json.js';
+import { insertFactoryUpdateScript, setAgentKitVersion } from '../lib/package-json.js';
 import { runPreflight } from '../lib/preflight.js';
 import { downloadProfileTarball, stageProfileTarball } from '../lib/unpack.js';
 /** Parse `update`'s argv slice into flags. Unknown flags are ignored here. */
@@ -186,7 +186,7 @@ function runResume(rootDir) {
     clearUpdateState(rootDir);
     const pkgPath = path.join(rootDir, 'package.json');
     if (existsSync(pkgPath))
-        maintainDerivedPkg(pkgPath);
+        maintainDerivedPkg(pkgPath, newLock.version);
     rmSync(state.stagedDir, { recursive: true, force: true });
     console.log('✔ `update` retomado y completado.');
 }
@@ -208,15 +208,16 @@ function warnOnScriptConflict(action, _pkgPath) {
 }
 /**
  * After a sync, maintain the derived project's package.json: ensure the
- * `factory:update` script (warn on a divergent value) and prune the stale
- * `agentKitVersion` leaked by the template. The lockfile — not package.json — is
- * the live-version SSOT, so that copy only drifts; pruning it here also cleans
- * derivatives that predate this fix on their next update. `factoryVersion` (the
- * frozen birth stamp) is kept.
+ * `factory:update` script (warn on a divergent value) and set `agentKitVersion`
+ * to the just-installed brain version, mirroring the lockfile's `version`. Run on
+ * every update, so the field tracks each `factory:update` (and a derivative whose
+ * field was missing or stale gets reconciled — same shape as the Factory's own
+ * package.json). `factoryVersion` (the frozen birth stamp) and `version` (the app
+ * semver) are untouched.
  */
-function maintainDerivedPkg(pkgPath) {
+function maintainDerivedPkg(pkgPath, agentKitVersion) {
     warnOnScriptConflict(insertFactoryUpdateScript(pkgPath).action, pkgPath);
-    pruneFactoryMeta(pkgPath);
+    setAgentKitVersion(pkgPath, agentKitVersion);
 }
 /** Print the deletes + kept-retired (design §7.6 — visible) + a one-line summary. */
 function reportSummary(diff) {
@@ -312,7 +313,7 @@ export async function runUpdate(flags, deps = {}) {
         clearUpdateState(rootDir);
         const pkgPath = path.join(rootDir, 'package.json');
         if (existsSync(pkgPath))
-            maintainDerivedPkg(pkgPath);
+            maintainDerivedPkg(pkgPath, manifest.version);
         reportSummary(diff);
     }
     finally {
@@ -352,7 +353,7 @@ async function applyLegacy(rootDir, stagedDir, manifest) {
     writeLockfile(rootDir, { ...manifest, factoryVersion: manifest.version });
     const pkgPath = path.join(rootDir, 'package.json');
     if (existsSync(pkgPath))
-        maintainDerivedPkg(pkgPath);
+        maintainDerivedPkg(pkgPath, manifest.version);
     if (plan.ambiguous.length > 0) {
         console.log('\nArchivos en `.claude/` que no están en el manifest (revisar manualmente):');
         for (const p of plan.ambiguous)

package/dist/lib/atomic-swap.js

@@ -20,7 +20,7 @@
  * paths). `src/` and dev-owned files are never in the plan, so they are never
  * read, written, or deleted here (design §7.2, §9 out-of-scope).
  */
-import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmdirSync, rmSync, writeFileSync, } from 'node:fs';
 import path from 'node:path';
 import { CLIError } from './cli-error.js';
 import { TIMEKAST_DIR } from './constants.js';
@@ -87,6 +87,33 @@ export function validateStagedManifest(stagedDir, manifestRaw) {
     }
     return manifest;
 }
+/**
+ * After deleting a tracked file, remove now-empty parent directories so a removed
+ * skill/dir does not leave an empty husk behind (e.g. deleting
+ * `.claude/skills/<name>/SKILL.md` should also drop the empty `<name>/` dir).
+ *
+ * Walks up from the file's directory, removing each empty dir, and stops at the
+ * first non-empty dir OR at a structural level — only directories at depth ≥ 3
+ * relative to the root are eligible, so `.claude`, `.claude/skills`, `scripts/tools`
+ * and the like always survive even if momentarily empty. Best-effort: any fs error
+ * just stops the walk. Path-separator agnostic (Windows-safe).
+ */
+function pruneEmptyDirs(rootDir, rel) {
+    const root = path.resolve(rootDir);
+    let dir = path.dirname(rel);
+    while (dir && dir !== '.' && dir.split(/[\\/]/).filter(Boolean).length >= 3) {
+        const abs = path.join(root, dir);
+        try {
+            if (!existsSync(abs) || readdirSync(abs).length > 0)
+                break;
+            rmdirSync(abs); // empty-dir only; throws (→ caught) if a race re-fills it
+        }
+        catch {
+            break;
+        }
+        dir = path.dirname(dir);
+    }
+}
 /**
  * Apply the plan atomically with a backup-and-rollback guard.
  *
@@ -147,6 +174,7 @@ export function applyPlan(rootDir, stagedDir, plan, backupDir, hooks) {
         hooks?.afterWrites?.();
         for (const rel of plan.deletes) {
             rmSync(path.join(rootDir, rel), { force: true, recursive: true });
+            pruneEmptyDirs(rootDir, rel);
         }
     }
     catch (error) {

package/dist/lib/package-json.js

@@ -31,31 +31,6 @@ export function parsePackageJson(raw) {
         throw new CLIError('El `package.json` desempacado no es JSON válido; no se puede continuar de forma segura.');
     }
 }
-/**
- * Stale Factory version metadata to prune from a derivative's `package.json`.
- *
- * The `full` template's `package.json` carries `factoryVersion` + `agentKitVersion`
- * for the Factory's dual-version release model, and both leak into a derivative on
- * unpack. Only `agentKitVersion` is pruned: it is the LIVE brain version, whose
- * SSOT in a derivative is `.timekast/lockfile.json` (`version`), so a `package.json`
- * copy just goes stale on every `update` and misleads (what `status`/`doctor` report
- * comes from the lockfile, never from here). `factoryVersion` is deliberately KEPT —
- * it is the FROZEN birth stamp (never changes after install) and the canonical
- * boilerplate marker (DISTRIBUTION_DESIGN §10). `version` (the derivative's own app
- * semver) is untouched.
- */
-const FACTORY_META_KEYS = ['agentKitVersion'];
-/** Delete stale Factory version metadata in place. Returns true if a key was removed. */
-function stripFactoryMeta(pkg) {
-    let changed = false;
-    for (const key of FACTORY_META_KEYS) {
-        if (key in pkg) {
-            delete pkg[key];
-            changed = true;
-        }
-    }
-    return changed;
-}
 /**
  * Pure core of the script insertion: mutate `pkg.scripts` in place to ensure
  * `factory:update` exists, never overwriting a divergent value. Shared by
@@ -88,9 +63,6 @@ export function applyPackageJsonEdits(raw, name) {
     const pkg = parsePackageJson(raw);
     pkg.name = name;
     const result = ensureUpdateScript(pkg);
-    // Prune the stale `agentKitVersion` leaked by the unpacked template; the
-    // derivative's live brain version lives in the lockfile, not here.
-    stripFactoryMeta(pkg);
     const content = `${JSON.stringify(pkg, null, indent)}\n`;
     return { content, scriptAlreadyPresent: result.action === 'conflict' };
 }
@@ -117,24 +89,27 @@ export function insertFactoryUpdateScript(pkgPath) {
     return result;
 }
 /**
- * Surgically prune the stale `agentKitVersion` leaked into a derived project's
- * `package.json` when the `full` profile is unpacked. It is NOT the version SSOT
- * — the lockfile is — so it goes stale on every update and misleads. Reads,
- * deletes only that key, and re-serializes with the original indentation, writing
- * only when something changed. NEVER touches `name`, `version`, `factoryVersion`
- * (the frozen birth stamp), deps, or scripts.
- *
- * Idempotent: a derivative already free of the key is left byte-identical.
+ * Surgically set the derived project's `package.json.agentKitVersion` to the
+ * installed brain version, mirroring the lockfile's `version`. The Factory's own
+ * `package.json` carries `agentKitVersion` and bumps it on every release; a
+ * derivative mirrors it so its `package.json` shows the live brain version and
+ * stays consistent with the Factory's shape. `update` calls this on every run, so
+ * the field tracks each `factory:update` — and a derivative whose field was missing
+ * or stale gets reconciled. Reads, sets only that key, re-serializes with the
+ * original indentation, and writes only when the value changed. NEVER touches
+ * `name`, `version` (the app semver), `factoryVersion` (birth stamp), deps, or scripts.
  *
  * @param pkgPath Absolute path to the derived project's `package.json`.
- * @returns true when a field was removed (and the file rewritten).
+ * @param version The installed brain version (= the lockfile's `version`).
+ * @returns true when the field changed (and the file was rewritten).
  */
-export function pruneFactoryMeta(pkgPath) {
+export function setAgentKitVersion(pkgPath, version) {
     const raw = readFileSync(pkgPath, 'utf8');
     const indent = detectIndent(raw);
     const pkg = parsePackageJson(raw);
-    if (!stripFactoryMeta(pkg))
+    if (pkg.agentKitVersion === version)
         return false;
+    pkg.agentKitVersion = version;
     writeFileSync(pkgPath, `${JSON.stringify(pkg, null, indent)}\n`, 'utf8');
     return true;
 }

package/package.json

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