@timekast/factory 2.4.0 → 2.6.0

package/dist/lib/vercel-env.js

@@ -183,6 +183,27 @@ export async function linkGitRepo(projectId, token, teamId, repo, deps = {}) {
         throw error;
     }
 }
+/**
+ * The project's current git connection, or `null` when it has none.
+ *
+ * @throws {VercelApiError} on any non-2xx.
+ */
+export async function getGitLink(projectId, token, teamId, deps = {}) {
+    const data = (await vercelApi('GET', `/v9/projects/${encodeURIComponent(projectId)}`, token, teamId, deps));
+    const link = data.link;
+    if (!link || link.type !== 'github' || typeof link.repoId !== 'number')
+        return null;
+    return { repo: `${link.org ?? ''}/${link.repo ?? ''}`, repoId: link.repoId };
+}
+/**
+ * Disconnect the project from its git repo (`DELETE /v9/projects/{id}/link`). The project,
+ * its env vars, domains and deployments stay; only the repo binding goes.
+ *
+ * @throws {VercelApiError} on any non-2xx.
+ */
+export async function unlinkGitRepo(projectId, token, teamId, deps = {}) {
+    await vercelApi('DELETE', `/v9/projects/${encodeURIComponent(projectId)}/link`, token, teamId, deps);
+}
 /**
  * Apply the project SETTINGS via `PATCH /v9/projects/{id}?teamId=` — the kit's
  * contract that `POST /v9/projects` refuses at create time:
@@ -828,6 +849,14 @@ export function buildEnvPlan(input) {
         { key: 'NEXT_PUBLIC_APP_URL', value: `https://${input.prodHost}`, target: ['production'] },
         { key: 'NEXT_PUBLIC_APP_URL', value: `https://${input.previewHost}`, target: ['preview'] },
     ];
+    // Per-env feature flags (PVMCP-001) — one record PER TARGET, like NEXT_PUBLIC_APP_ENV, so a later
+    // change in one target (`/deploy` turns questions off in production) never drags the other.
+    // Without MCP, `MCP_ENABLED` is not written at all: absent means off.
+    const flags = ['QUESTIONS_ENABLED', ...(input.mcp ? ['MCP_ENABLED'] : [])];
+    for (const key of flags) {
+        plan.push({ key, value: 'true', target: ['production'] });
+        plan.push({ key, value: 'true', target: ['preview'] });
+    }
     for (const [key, value] of Object.entries(input.shared ?? {})) {
         if (!value)
             continue; // skip empty shared values

package/dist/lib/whats-new.js

@@ -0,0 +1,123 @@
+/**
+ * The "what's new" block printed after every applied `factory update`.
+ *
+ * WHY IT EXISTS. A version number tells the dev that something changed, not what. The kit's
+ * changelog already travels with the brain (`.claude/docs/CHANGELOG.md`, tracked), but nobody
+ * opens it after an update: the dev reads "✔ v14.0.0" and moves on without knowing the kit
+ * now has a client-questions section or a new rule they are expected to follow. This block
+ * puts the headline of every release they just crossed in front of them, before the retrofit
+ * reminder — first what changed, then what still needs hands.
+ *
+ * Read from disk AFTER the apply, like the retrofit reminder: the changelog that just arrived
+ * is the source, never a list baked into this binary. Headless too — an agent running the
+ * update is the reader who has to relay it to the dev.
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { compareVersions } from './retrofit-reminder.js';
+/** Where the kit's changelog lives inside the derivative. */
+export const KIT_CHANGELOG = '.claude/docs/CHANGELOG.md';
+/** Releases shown in full; older ones crossed by the same update collapse into one line. */
+export const MAX_RELEASES = 5;
+/** Headlines shown per release; the rest collapse into "+N más". */
+export const MAX_ITEMS_PER_RELEASE = 8;
+/** How much of a headline survives — enough to understand, short enough to scan. */
+const ITEM_MAX = 110;
+/** `## [13.6.0] - 2026-10-14 — Title` → version + title. `[Unreleased]` and junk → null. */
+function parseHeading(line) {
+    const match = line.match(/^##\s+\[(\d+\.\d+\.\d+)\]\s*(.*)$/);
+    if (!match)
+        return null;
+    const rest = match[2];
+    const dash = rest.indexOf('—');
+    const title = dash === -1 ? null : rest.slice(dash + 1).trim() || null;
+    return { version: match[1], title };
+}
+/** Markdown inline marks out: the block is plain terminal text. */
+function plain(text) {
+    return text
+        .replace(/\*\*/g, '')
+        .replace(/`/g, '')
+        .replace(/\[([^\]]+)\]\([^)]*\)/g, '$1')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+/** A bullet's headline: its leading bold span, else its first sentence. Capped. */
+export function headline(bullet) {
+    const body = bullet.replace(/^-\s+/, '');
+    const bold = body.match(/^\*\*(.+?)\*\*/);
+    let text = plain(bold ? bold[1] : (body.match(/^(.+?[.!?])(\s|$)/)?.[1] ?? body));
+    text = text.replace(/[.:]$/, '');
+    return text.length > ITEM_MAX ? `${text.slice(0, ITEM_MAX - 1)}…` : text;
+}
+/**
+ * Every numbered release in the changelog, newest first, with its top-level bullets.
+ * Sub-bullets, `###` group headings and prose are skipped: the headline is the bullet itself.
+ */
+export function parseChangelog(markdown) {
+    const releases = [];
+    let current = null;
+    for (const line of markdown.split('\n')) {
+        if (line.startsWith('## ')) {
+            const heading = parseHeading(line);
+            current = heading ? { ...heading, items: [] } : null;
+            if (current)
+                releases.push(current);
+            continue;
+        }
+        if (current && /^-\s+\S/.test(line))
+            current.items.push(headline(line));
+    }
+    return releases.sort((a, b) => compareVersions(b.version, a.version));
+}
+/**
+ * The releases this update crossed: newer than `fromVersion`. Without a `fromVersion` (first
+ * install) there is nothing to compare against and the block stays silent — "everything is
+ * new" helps nobody. A legacy `0.0.0` lockfile crosses every release, and the cap handles it.
+ */
+export function releasesSince(releases, fromVersion) {
+    if (!fromVersion)
+        return [];
+    return releases.filter((r) => compareVersions(r.version, fromVersion) > 0);
+}
+/** Render the block, or `null` when the update crossed no documented release. */
+export function renderWhatsNew(crossed) {
+    if (crossed.length === 0)
+        return null;
+    const rule = '═'.repeat(74);
+    const lines = ['', rule, '  ✨  NOVEDADES DEL KIT EN ESTE UPDATE', rule, ''];
+    for (const release of crossed.slice(0, MAX_RELEASES)) {
+        lines.push(`  ▸ v${release.version}${release.title ? ` — ${release.title}` : ''}`, '');
+        for (const item of release.items.slice(0, MAX_ITEMS_PER_RELEASE))
+            lines.push(`    · ${item}`);
+        const extra = release.items.length - MAX_ITEMS_PER_RELEASE;
+        if (extra > 0)
+            lines.push(`    · +${extra} más`);
+        lines.push('');
+    }
+    const older = crossed.length - MAX_RELEASES;
+    if (older > 0) {
+        const oldest = crossed[crossed.length - 1].version;
+        lines.push(`  ▸ Y ${older} versión(es) anteriores, hasta v${oldest}.`, '');
+    }
+    lines.push(`  El detalle de cada punto está en ${KIT_CHANGELOG}.`, '  Si trabajas con un agente, pídele que te explique qué cambia para tu proyecto.', rule, '');
+    return lines.join('\n');
+}
+/**
+ * Print the block. A missing or unreadable changelog prints nothing — a `core` derivative may
+ * not carry it, and a notice must never break the update that already succeeded.
+ */
+export function printWhatsNew(opts) {
+    const readFile = opts.readFile ?? ((file) => readFileSync(file, 'utf8'));
+    const log = opts.log ?? ((m) => console.log(m));
+    let markdown;
+    try {
+        markdown = readFile(join(opts.rootDir, KIT_CHANGELOG));
+    }
+    catch {
+        return;
+    }
+    const rendered = renderWhatsNew(releasesSince(parseChangelog(markdown), opts.fromVersion));
+    if (rendered)
+        log(rendered);
+}

package/package.json

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