@edcalderon/versioning 1.0.11 → 1.1.2

package/CHANGELOG.md

@@ -1,3 +1,49 @@
+# [1.1.0](https://github.com/edcalderon/my-second-brain/compare/v1.1.4...v1.1.0) (2026-02-12)
+
+
+### Bug Fixes
+
+* add force-static export to API routes for static export compatibility ([6333e2d](https://github.com/edcalderon/my-second-brain/commit/6333e2d2b3ae149b5b893520271e7a0e171bace8))
+* add search method to supermemory wrapper ([75f646a](https://github.com/edcalderon/my-second-brain/commit/75f646a377ee96a2ef66e9225b003ef19e25277e))
+* change Next.js output to export for static GitHub Pages deployment ([c94fded](https://github.com/edcalderon/my-second-brain/commit/c94fdedda9b311b1aae27ddce4b2c9bb6083b325))
+* lazy-load supermemory to allow builds without API key ([6892009](https://github.com/edcalderon/my-second-brain/commit/68920097e9aeabe76d8a08e45d96837ba009f32d))
+* make environment variable check optional in deploy-web workflow ([e6cb9b0](https://github.com/edcalderon/my-second-brain/commit/e6cb9b0873fc9244fbc104f2bb832056e1ffd44c))
+* pin pnpm version to 8.15.9 in GitHub Actions workflows for lockfile compatibility ([3a8538e](https://github.com/edcalderon/my-second-brain/commit/3a8538e3e2f84f21b4ad98d2c878eac8e6c065f7))
+* relax pnpm version requirement to >=8.0.0 for CI compatibility ([9aa90ac](https://github.com/edcalderon/my-second-brain/commit/9aa90acc92b62debd0e0e840a493d30e71821b38))
+
+
+### Features
+
+* **gcp-functions:** Implement automated GitHub daily screenshot and tweet ([b3366d4](https://github.com/edcalderon/my-second-brain/commit/b3366d4a13858ae2702f9f4cd16216a41f650a83))
+* **versioning:** reentry status roadmap layer (v1.1.0) ([f6e94e5](https://github.com/edcalderon/my-second-brain/commit/f6e94e5dfc1fdd386d4ae9612c083155a2c803e8))
+
+
+
+
+
+# [1.1.0](https://github.com/edcalderon/my-second-brain/compare/v1.1.4...v1.1.0) (2026-02-12)
+
+
+### Bug Fixes
+
+* add force-static export to API routes for static export compatibility ([6333e2d](https://github.com/edcalderon/my-second-brain/commit/6333e2d2b3ae149b5b893520271e7a0e171bace8))
+* add search method to supermemory wrapper ([75f646a](https://github.com/edcalderon/my-second-brain/commit/75f646a377ee96a2ef66e9225b003ef19e25277e))
+* change Next.js output to export for static GitHub Pages deployment ([c94fded](https://github.com/edcalderon/my-second-brain/commit/c94fdedda9b311b1aae27ddce4b2c9bb6083b325))
+* lazy-load supermemory to allow builds without API key ([6892009](https://github.com/edcalderon/my-second-brain/commit/68920097e9aeabe76d8a08e45d96837ba009f32d))
+* make environment variable check optional in deploy-web workflow ([e6cb9b0](https://github.com/edcalderon/my-second-brain/commit/e6cb9b0873fc9244fbc104f2bb832056e1ffd44c))
+* pin pnpm version to 8.15.9 in GitHub Actions workflows for lockfile compatibility ([3a8538e](https://github.com/edcalderon/my-second-brain/commit/3a8538e3e2f84f21b4ad98d2c878eac8e6c065f7))
+* relax pnpm version requirement to >=8.0.0 for CI compatibility ([9aa90ac](https://github.com/edcalderon/my-second-brain/commit/9aa90acc92b62debd0e0e840a493d30e71821b38))
+
+
+### Features
+
+* **gcp-functions:** Implement automated GitHub daily screenshot and tweet ([b3366d4](https://github.com/edcalderon/my-second-brain/commit/b3366d4a13858ae2702f9f4cd16216a41f650a83))
+* **versioning:** reentry status roadmap layer (v1.1.0) ([f6e94e5](https://github.com/edcalderon/my-second-brain/commit/f6e94e5dfc1fdd386d4ae9612c083155a2c803e8))
+
+
+
+
+
 ## [1.0.11](https://github.com/edcalderon/my-second-brain/compare/v1.0.10...v1.0.11) (2026-01-02)
 
 

package/README.md

@@ -113,6 +113,56 @@ Features:
 - Local registry support
 - Dry-run mode
 
+#### Re-entry Status + Roadmap Extension
+
+Maintains a fast **re-entry** layer (current state + next micro-step) and a slow **roadmap/backlog** layer (long-term plan).
+
+Canonical files:
+
+Single-project (default):
+- `.versioning/reentry.status.json` (machine)
+- `.versioning/REENTRY.md` (generated, minimal diffs)
+- `.versioning/ROADMAP.md` (human-first; only a small managed header block is auto-updated)
+
+Multi-project (scoped by `--project <name>`):
+- `.versioning/projects/<project>/reentry.status.json`
+- `.versioning/projects/<project>/REENTRY.md`
+- `.versioning/projects/<project>/ROADMAP.md`
+
+Notes:
+- `--project` must match an existing workspace app/package (it can be a slug like `trader`, a scoped package name like `@ed/trader`, or a path like `apps/trader`).
+- The canonical project key is the last path segment (e.g. `@ed/trader` → `trader`).
+
+Commands:
+
+```bash
+# Fast layer
+versioning reentry init
+versioning reentry sync
+
+# Fast layer (scoped)
+versioning reentry init --project trader
+versioning reentry sync --project trader
+
+# Slow layer
+versioning roadmap init --title "My Project"
+versioning roadmap list
+versioning roadmap set-milestone --id "now-01" --title "Ship X"
+versioning roadmap add --section Now --id "now-02" --item "Add observability"
+
+# Slow layer (scoped)
+versioning roadmap init --project trader --title "Trader"
+versioning roadmap list --project trader
+versioning roadmap add --project trader --section Now --item "Wire user-data ORDER_* events"
+
+# Detect stale/mismatched scoped roadmaps
+versioning roadmap validate
+```
+
+Backward compatibility:
+- v1.0 status files load safely.
+- Schema migrates to v1.1 only when you actually modify status, or explicitly via `versioning reentry sync --migrate`.
+
 ### External Extensions
 
 To use external extensions, add them to your `versioning.config.json`:

package/dist/cli.js

@@ -41,11 +41,13 @@ const changelog_1 = require("./changelog");
 const sync_1 = require("./sync");
 const release_1 = require("./release");
 const extensions_1 = require("./extensions");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const pkg = require('../package.json');
 const program = new commander_1.Command();
 program
     .name('versioning')
     .description('Comprehensive versioning and changelog management for monorepos')
-    .version('1.0.4');
+    .version(pkg.version || '0.0.0');
 program
     .command('bump <type>')
     .description('Bump version (patch, minor, major, prerelease)')

package/dist/extensions/reentry-status/config-manager.d.ts

@@ -0,0 +1,17 @@
+import { ReentryStatusConfig, SyncTarget } from './models';
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends Array<infer U> ? Array<DeepPartial<U>> : T[K] extends object ? DeepPartial<T[K]> : T[K];
+};
+export declare function canonicalProjectKey(project?: string): string | undefined;
+export declare class ConfigManager {
+    static loadConfig(rootConfig: any, project?: string): ReentryStatusConfig;
+    static mergeWithDefaults(partial: DeepPartial<ReentryStatusConfig>, project?: string): ReentryStatusConfig;
+    static validateConfig(config: ReentryStatusConfig): ValidationResult;
+    static getSyncTargets(config: ReentryStatusConfig): SyncTarget[];
+}
+export {};
+//# sourceMappingURL=config-manager.d.ts.map

package/dist/extensions/reentry-status/config-manager.js

@@ -0,0 +1,187 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigManager = void 0;
+exports.canonicalProjectKey = canonicalProjectKey;
+const path = __importStar(require("path"));
+const constants_1 = require("./constants");
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function defaultFilesConfig() {
+    return {
+        jsonPath: path.join(constants_1.REENTRY_STATUS_DIRNAME, constants_1.REENTRY_STATUS_JSON_FILENAME),
+        markdownPath: path.join(constants_1.REENTRY_STATUS_DIRNAME, constants_1.REENTRY_STATUS_MD_FILENAME)
+    };
+}
+function canonicalProjectKey(project) {
+    const raw = typeof project === 'string' ? project.trim() : '';
+    if (!raw)
+        return undefined;
+    // Prefer the last segment for scoped package names (e.g. "@ed/trader" -> "trader").
+    if (raw.startsWith('@') && raw.includes('/')) {
+        const parts = raw.split('/').filter(Boolean);
+        const last = parts[parts.length - 1]?.trim();
+        return last || undefined;
+    }
+    // Also handle path-like inputs (e.g. "apps/trader" -> "trader").
+    if (raw.includes('/')) {
+        const parts = raw.split('/').filter(Boolean);
+        const last = parts[parts.length - 1]?.trim();
+        return last || undefined;
+    }
+    return raw;
+}
+function toProjectDir(project) {
+    const raw = canonicalProjectKey(project) ?? '';
+    if (!raw)
+        return constants_1.REENTRY_STATUS_DIRNAME;
+    const safe = raw
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return path.join(constants_1.REENTRY_STATUS_DIRNAME, 'projects', safe || 'project');
+}
+function defaultFilesConfigForProject(project) {
+    const dir = toProjectDir(project);
+    return {
+        jsonPath: path.join(dir, constants_1.REENTRY_STATUS_JSON_FILENAME),
+        markdownPath: path.join(dir, constants_1.REENTRY_STATUS_MD_FILENAME),
+    };
+}
+class ConfigManager {
+    static loadConfig(rootConfig, project) {
+        const canonicalProject = canonicalProjectKey(project);
+        const raw = (rootConfig && typeof rootConfig === 'object' ? rootConfig.reentryStatus : undefined);
+        const basePartial = { ...(raw ?? {}) };
+        delete basePartial.projects;
+        const projectPartial = canonicalProject && raw && typeof raw === 'object' && raw.projects && typeof raw.projects === 'object'
+            ? raw.projects[String(canonicalProject)] ?? raw.projects[String(project)]
+            : undefined;
+        if (!projectPartial) {
+            return ConfigManager.mergeWithDefaults(basePartial, canonicalProject);
+        }
+        const merged = {
+            ...basePartial,
+            ...projectPartial,
+            hooks: {
+                ...basePartial.hooks,
+                ...projectPartial.hooks,
+            },
+            files: {
+                ...basePartial.files,
+                ...projectPartial.files,
+            },
+            template: projectPartial.template
+                ? {
+                    includeSections: projectPartial.template.includeSections ?? basePartial.template?.includeSections ?? [],
+                    excludeSections: projectPartial.template.excludeSections ?? basePartial.template?.excludeSections ?? [],
+                    customSections: projectPartial.template.customSections ?? basePartial.template?.customSections,
+                }
+                : basePartial.template,
+            github: projectPartial.github ?? basePartial.github,
+            obsidian: projectPartial.obsidian ?? basePartial.obsidian,
+        };
+        return ConfigManager.mergeWithDefaults(merged, canonicalProject);
+    }
+    static mergeWithDefaults(partial, project) {
+        const defaults = defaultFilesConfigForProject(project);
+        const merged = {
+            enabled: partial.enabled ?? true,
+            autoSync: partial.autoSync ?? true,
+            failHard: partial.failHard ?? false,
+            hooks: {
+                postVersion: partial.hooks?.postVersion ?? true,
+                postRelease: partial.hooks?.postRelease ?? false
+            },
+            files: {
+                jsonPath: partial.files?.jsonPath ?? defaults.jsonPath,
+                markdownPath: partial.files?.markdownPath ?? defaults.markdownPath
+            },
+            github: partial.github,
+            obsidian: partial.obsidian,
+            template: partial.template
+                ? {
+                    includeSections: partial.template.includeSections ?? [],
+                    excludeSections: partial.template.excludeSections ?? [],
+                    customSections: partial.template.customSections
+                }
+                : undefined
+        };
+        return merged;
+    }
+    static validateConfig(config) {
+        const errors = [];
+        if (!config.files || !isNonEmptyString(config.files.jsonPath) || !isNonEmptyString(config.files.markdownPath)) {
+            errors.push('files.jsonPath and files.markdownPath must be non-empty strings');
+        }
+        if (config.github?.enabled) {
+            if (!isNonEmptyString(config.github.owner))
+                errors.push('github.owner is required when github.enabled is true');
+            if (!isNonEmptyString(config.github.repo))
+                errors.push('github.repo is required when github.enabled is true');
+            if (!config.github.issue || !isNonEmptyString(config.github.issue.title)) {
+                errors.push('github.issue.title is required when github.enabled is true');
+            }
+            if (!config.github.issue || !Array.isArray(config.github.issue.labels)) {
+                errors.push('github.issue.labels must be an array when github.enabled is true');
+            }
+            if (!config.github.auth || !isNonEmptyString(config.github.auth.token)) {
+                errors.push('github.auth.token is required when github.enabled is true');
+            }
+        }
+        if (config.obsidian?.enabled) {
+            if (!isNonEmptyString(config.obsidian.vaultPath)) {
+                errors.push('obsidian.vaultPath is required when obsidian.enabled is true');
+            }
+            if (!isNonEmptyString(config.obsidian.notePath)) {
+                errors.push('obsidian.notePath is required when obsidian.enabled is true');
+            }
+        }
+        return { valid: errors.length === 0, errors };
+    }
+    static getSyncTargets(config) {
+        if (!config.enabled)
+            return [];
+        const targets = ['files'];
+        if (config.github?.enabled)
+            targets.push('github');
+        if (config.obsidian?.enabled)
+            targets.push('obsidian');
+        return targets;
+    }
+}
+exports.ConfigManager = ConfigManager;
+//# sourceMappingURL=config-manager.js.map

package/dist/extensions/reentry-status/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const REENTRY_EXTENSION_NAME = "reentry-status-extension";
+export declare const REENTRY_STATUS_DIRNAME = ".versioning";
+export declare const REENTRY_STATUS_JSON_FILENAME = "reentry.status.json";
+export declare const REENTRY_STATUS_MD_FILENAME = "REENTRY.md";
+export declare const ROADMAP_MD_FILENAME = "ROADMAP.md";
+//# sourceMappingURL=constants.d.ts.map

package/dist/extensions/reentry-status/constants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROADMAP_MD_FILENAME = exports.REENTRY_STATUS_MD_FILENAME = exports.REENTRY_STATUS_JSON_FILENAME = exports.REENTRY_STATUS_DIRNAME = exports.REENTRY_EXTENSION_NAME = void 0;
+exports.REENTRY_EXTENSION_NAME = 'reentry-status-extension';
+exports.REENTRY_STATUS_DIRNAME = '.versioning';
+exports.REENTRY_STATUS_JSON_FILENAME = 'reentry.status.json';
+exports.REENTRY_STATUS_MD_FILENAME = 'REENTRY.md';
+exports.ROADMAP_MD_FILENAME = 'ROADMAP.md';
+//# sourceMappingURL=constants.js.map

package/dist/extensions/reentry-status/dirty-detection.d.ts

@@ -0,0 +1,4 @@
+export declare function normalizeBody(body: string): string;
+export declare function bodiesEqual(a: string, b: string): boolean;
+export declare function sha256(text: string): string;
+//# sourceMappingURL=dirty-detection.d.ts.map

package/dist/extensions/reentry-status/dirty-detection.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeBody = normalizeBody;
+exports.bodiesEqual = bodiesEqual;
+exports.sha256 = sha256;
+const crypto_1 = require("crypto");
+function normalizeBody(body) {
+    // Normalize EOL and ensure a trailing newline for stable comparisons.
+    const normalized = body.replace(/\r\n/g, '\n');
+    return normalized.endsWith('\n') ? normalized : `${normalized}\n`;
+}
+function bodiesEqual(a, b) {
+    return normalizeBody(a) === normalizeBody(b);
+}
+function sha256(text) {
+    return (0, crypto_1.createHash)('sha256').update(normalizeBody(text), 'utf8').digest('hex');
+}
+//# sourceMappingURL=dirty-detection.js.map

package/dist/extensions/reentry-status/file-manager.d.ts

@@ -0,0 +1,29 @@
+import { ReentryStatus } from './models';
+export interface FileSystem {
+    pathExists(filePath: string): Promise<boolean>;
+    ensureDir(dirPath: string): Promise<void>;
+    readFile(filePath: string, encoding: 'utf8'): Promise<string>;
+    writeFile(filePath: string, content: string, encoding: 'utf8'): Promise<void>;
+    move(src: string, dest: string, options: {
+        overwrite: boolean;
+    }): Promise<void>;
+    remove(filePath: string): Promise<void>;
+}
+export declare class FileManager {
+    private readonly fs;
+    constructor(fs?: FileSystem);
+    ensureDirForFile(filePath: string): Promise<void>;
+    readFileIfExists(filePath: string): Promise<string | null>;
+    writeFileIfChanged(filePath: string, content: string): Promise<boolean>;
+    /**
+     * Writes both JSON and Markdown status files as a single operation.
+     * Best-effort atomicity: either both are updated, or any partial update is rolled back.
+     */
+    writeStatusFiles(config: any, status: ReentryStatus): Promise<{
+        changed: boolean;
+    }>;
+    loadStatus(config: any): Promise<ReentryStatus | null>;
+    writeStatusJson(config: any, status: ReentryStatus): Promise<boolean>;
+    writeReentryMarkdown(config: any, status: ReentryStatus): Promise<boolean>;
+}
+//# sourceMappingURL=file-manager.d.ts.map

package/dist/extensions/reentry-status/file-manager.js

@@ -0,0 +1,144 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileManager = void 0;
+const fsExtra = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const config_manager_1 = require("./config-manager");
+const status_renderer_1 = require("./status-renderer");
+class FileManager {
+    constructor(fs = fsExtra) {
+        this.fs = fs;
+    }
+    async ensureDirForFile(filePath) {
+        await this.fs.ensureDir(path.dirname(filePath));
+    }
+    async readFileIfExists(filePath) {
+        if (!(await this.fs.pathExists(filePath)))
+            return null;
+        return await this.fs.readFile(filePath, 'utf8');
+    }
+    async writeFileIfChanged(filePath, content) {
+        const prev = await this.readFileIfExists(filePath);
+        if (prev !== null && prev.replace(/\r\n/g, '\n') === content.replace(/\r\n/g, '\n')) {
+            return false;
+        }
+        await this.ensureDirForFile(filePath);
+        const tmpPath = `${filePath}.tmp`;
+        await this.fs.writeFile(tmpPath, content, 'utf8');
+        await this.fs.move(tmpPath, filePath, { overwrite: true });
+        return true;
+    }
+    /**
+     * Writes both JSON and Markdown status files as a single operation.
+     * Best-effort atomicity: either both are updated, or any partial update is rolled back.
+     */
+    async writeStatusFiles(config, status) {
+        const reentryConfig = config_manager_1.ConfigManager.loadConfig(config);
+        const jsonPath = reentryConfig.files.jsonPath;
+        const markdownPath = reentryConfig.files.markdownPath;
+        const nextJson = status_renderer_1.StatusRenderer.renderJson(status);
+        const nextMarkdown = status_renderer_1.StatusRenderer.renderMarkdown(status);
+        const prevJson = await this.readFileIfExists(jsonPath);
+        const prevMarkdown = await this.readFileIfExists(markdownPath);
+        const jsonSame = prevJson !== null && prevJson.replace(/\r\n/g, '\n') === nextJson.replace(/\r\n/g, '\n');
+        const mdSame = prevMarkdown !== null && prevMarkdown.replace(/\r\n/g, '\n') === nextMarkdown.replace(/\r\n/g, '\n');
+        if (jsonSame && mdSame)
+            return { changed: false };
+        await this.ensureDirForFile(jsonPath);
+        await this.ensureDirForFile(markdownPath);
+        const jsonTmp = `${jsonPath}.tmp`;
+        const mdTmp = `${markdownPath}.tmp`;
+        // Stage temp files first.
+        await this.fs.writeFile(jsonTmp, nextJson, 'utf8');
+        await this.fs.writeFile(mdTmp, nextMarkdown, 'utf8');
+        let jsonMoved = false;
+        try {
+            await this.fs.move(jsonTmp, jsonPath, { overwrite: true });
+            jsonMoved = true;
+            await this.fs.move(mdTmp, markdownPath, { overwrite: true });
+            return { changed: true };
+        }
+        catch (error) {
+            // Clean up temp files (ignore errors).
+            try {
+                if (await this.fs.pathExists(jsonTmp))
+                    await this.fs.remove(jsonTmp);
+            }
+            catch { }
+            try {
+                if (await this.fs.pathExists(mdTmp))
+                    await this.fs.remove(mdTmp);
+            }
+            catch { }
+            // Roll back JSON if it was moved but Markdown wasn't.
+            if (jsonMoved) {
+                try {
+                    if (prevJson === null) {
+                        await this.fs.remove(jsonPath);
+                    }
+                    else {
+                        const rollbackTmp = `${jsonPath}.rollback.tmp`;
+                        await this.fs.writeFile(rollbackTmp, prevJson, 'utf8');
+                        await this.fs.move(rollbackTmp, jsonPath, { overwrite: true });
+                    }
+                }
+                catch {
+                    // If rollback fails, rethrow original error.
+                }
+            }
+            throw error;
+        }
+    }
+    async loadStatus(config) {
+        const reentryConfig = config_manager_1.ConfigManager.loadConfig(config);
+        const jsonContent = await this.readFileIfExists(reentryConfig.files.jsonPath);
+        if (!jsonContent)
+            return null;
+        return status_renderer_1.StatusRenderer.parseJson(jsonContent);
+    }
+    async writeStatusJson(config, status) {
+        const reentryConfig = config_manager_1.ConfigManager.loadConfig(config);
+        const json = status_renderer_1.StatusRenderer.renderJson(status);
+        return await this.writeFileIfChanged(reentryConfig.files.jsonPath, json);
+    }
+    async writeReentryMarkdown(config, status) {
+        const reentryConfig = config_manager_1.ConfigManager.loadConfig(config);
+        const md = status_renderer_1.StatusRenderer.renderMarkdown(status);
+        return await this.writeFileIfChanged(reentryConfig.files.markdownPath, md);
+    }
+}
+exports.FileManager = FileManager;
+//# sourceMappingURL=file-manager.js.map

package/dist/extensions/reentry-status/github-rest-client.d.ts

@@ -0,0 +1,29 @@
+import { GitHubClient, GitHubIssue } from './github-sync-adapter';
+export declare class GitHubRestClient implements GitHubClient {
+    private readonly token;
+    constructor(token: string);
+    private request;
+    findIssueByTitle(params: {
+        owner: string;
+        repo: string;
+        title: string;
+    }): Promise<GitHubIssue | null>;
+    createIssue(params: {
+        owner: string;
+        repo: string;
+        title: string;
+        body: string;
+        labels: string[];
+        assignees?: string[];
+    }): Promise<GitHubIssue>;
+    updateIssue(params: {
+        owner: string;
+        repo: string;
+        issueId: number;
+        title?: string;
+        body: string;
+        labels?: string[];
+        assignees?: string[];
+    }): Promise<GitHubIssue>;
+}
+//# sourceMappingURL=github-rest-client.d.ts.map

package/dist/extensions/reentry-status/github-rest-client.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHubRestClient = void 0;
+class GitHubRestClient {
+    constructor(token) {
+        this.token = token;
+    }
+    async request(method, url, body) {
+        const res = await fetch(url, {
+            method,
+            headers: {
+                Accept: 'application/vnd.github+json',
+                Authorization: `Bearer ${this.token}`,
+                'X-GitHub-Api-Version': '2022-11-28',
+                'Content-Type': 'application/json'
+            },
+            body: body ? JSON.stringify(body) : undefined
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`GitHub API error ${res.status} ${res.statusText}: ${text}`);
+        }
+        return (await res.json());
+    }
+    async findIssueByTitle(params) {
+        // Minimal approach: list open issues and match exact title.
+        // (Avoid Search API auth/perms complexity; keep behavior deterministic.)
+        const url = `https://api.github.com/repos/${params.owner}/${params.repo}/issues?state=open&per_page=100`;
+        const issues = await this.request('GET', url);
+        const match = issues.find((i) => typeof i?.title === 'string' && i.title === params.title);
+        if (!match)
+            return null;
+        return {
+            id: Number(match.number),
+            url: String(match.html_url ?? ''),
+            title: String(match.title),
+            body: String(match.body ?? '')
+        };
+    }
+    async createIssue(params) {
+        const url = `https://api.github.com/repos/${params.owner}/${params.repo}/issues`;
+        const created = await this.request('POST', url, {
+            title: params.title,
+            body: params.body,
+            labels: params.labels,
+            assignees: params.assignees
+        });
+        return {
+            id: Number(created.number),
+            url: String(created.html_url ?? ''),
+            title: String(created.title),
+            body: String(created.body ?? '')
+        };
+    }
+    async updateIssue(params) {
+        const url = `https://api.github.com/repos/${params.owner}/${params.repo}/issues/${params.issueId}`;
+        const updated = await this.request('PATCH', url, {
+            title: params.title,
+            body: params.body,
+            labels: params.labels,
+            assignees: params.assignees
+        });
+        return {
+            id: Number(updated.number),
+            url: String(updated.html_url ?? ''),
+            title: String(updated.title),
+            body: String(updated.body ?? '')
+        };
+    }
+}
+exports.GitHubRestClient = GitHubRestClient;
+//# sourceMappingURL=github-rest-client.js.map