@edcalderon/versioning 1.0.11 → 1.1.2

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

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReentryStatusManager = void 0;
+const config_manager_1 = require("./config-manager");
+const file_manager_1 = require("./file-manager");
+const dirty_detection_1 = require("./dirty-detection");
+const github_rest_client_1 = require("./github-rest-client");
+const github_sync_adapter_1 = require("./github-sync-adapter");
+const obsidian_cli_client_1 = require("./obsidian-cli-client");
+const obsidian_sync_adapter_1 = require("./obsidian-sync-adapter");
+const roadmap_renderer_1 = require("./roadmap-renderer");
+const status_renderer_1 = require("./status-renderer");
+class ReentryStatusManager {
+    constructor(options = {}) {
+        this.fileManager = options.fileManager ?? new file_manager_1.FileManager();
+        this.createGitHubSyncer = options.createGitHubSyncer;
+        this.createObsidianSyncer = options.createObsidianSyncer;
+        this.isObsidianAvailable = options.isObsidianAvailable;
+    }
+    createInitialStatus() {
+        return {
+            schemaVersion: '1.1',
+            version: '0.0.0',
+            lastUpdated: new Date(0).toISOString(),
+            updatedBy: 'unknown',
+            context: {
+                trigger: 'manual',
+                gitInfo: { branch: '', commit: '', author: '', timestamp: new Date(0).toISOString() },
+                versioningInfo: {}
+            },
+            milestone: null,
+            roadmapFile: roadmap_renderer_1.RoadmapRenderer.defaultRoadmapPath(),
+            currentPhase: 'planning',
+            milestones: [],
+            blockers: [],
+            nextSteps: [],
+            risks: [],
+            dependencies: [],
+            versioning: {
+                currentVersion: '0.0.0',
+                previousVersion: '0.0.0',
+                versionType: 'patch'
+            },
+            syncMetadata: {
+                lastSyncAttempt: new Date(0).toISOString(),
+                lastSuccessfulSync: new Date(0).toISOString()
+            }
+        };
+    }
+    async loadOrInit(rootConfig) {
+        const existing = await this.fileManager.loadStatus(rootConfig);
+        if (existing)
+            return existing;
+        const initial = this.createInitialStatus();
+        await this.fileManager.writeStatusFiles(rootConfig, initial);
+        return initial;
+    }
+    async updateStatus(rootConfig, updater) {
+        const current = await this.loadOrInit(rootConfig);
+        const next = updater(current);
+        await this.fileManager.writeStatusFiles(rootConfig, next);
+        return next;
+    }
+    async applyContext(rootConfig, context) {
+        return await this.updateStatus(rootConfig, (current) => ({
+            ...current,
+            schemaVersion: '1.1',
+            context,
+            lastUpdated: new Date().toISOString()
+        }));
+    }
+    async ensureRoadmapExists(rootConfig, status) {
+        const roadmapPath = status.roadmapFile || roadmap_renderer_1.RoadmapRenderer.defaultRoadmapPath();
+        const existing = await this.fileManager.readFileIfExists(roadmapPath);
+        if (!existing) {
+            await this.fileManager.writeFileIfChanged(roadmapPath, roadmap_renderer_1.RoadmapRenderer.renderTemplate({}, { milestone: status.milestone, roadmapFile: roadmapPath }));
+            return;
+        }
+        const upserted = roadmap_renderer_1.RoadmapRenderer.upsertManagedBlock(existing, { milestone: status.milestone, roadmapFile: roadmapPath });
+        if (upserted.changed) {
+            await this.fileManager.writeFileIfChanged(roadmapPath, upserted.content);
+        }
+    }
+    async syncAll(rootConfig, targets) {
+        const config = config_manager_1.ConfigManager.loadConfig(rootConfig);
+        const actualTargets = targets ?? config_manager_1.ConfigManager.getSyncTargets(config);
+        const status = await this.loadOrInit(rootConfig);
+        const results = [];
+        // Always keep local files up to date if requested.
+        if (actualTargets.includes('files')) {
+            const started = Date.now();
+            try {
+                await this.fileManager.writeStatusFiles(rootConfig, status);
+                await this.ensureRoadmapExists(rootConfig, status);
+                results.push({ target: 'files', success: true, timestamp: new Date().toISOString(), duration: Date.now() - started });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                results.push({
+                    target: 'files',
+                    success: false,
+                    timestamp: new Date().toISOString(),
+                    duration: Date.now() - started,
+                    error: { message, recoverable: false }
+                });
+                throw error;
+            }
+        }
+        const reentryMarkdown = status_renderer_1.StatusRenderer.renderMarkdown(status);
+        if (actualTargets.includes('github') && config.github?.enabled) {
+            const started = Date.now();
+            try {
+                const syncer = this.createGitHubSyncer
+                    ? this.createGitHubSyncer(config.github)
+                    : new github_sync_adapter_1.GitHubSyncAdapter(config.github, new github_rest_client_1.GitHubRestClient(config.github.auth.token));
+                const result = await syncer.sync(status, reentryMarkdown);
+                results.push(result);
+                const body = syncer.renderIssueBody(status, reentryMarkdown);
+                const bodyHash = (0, dirty_detection_1.sha256)(body);
+                if (result.details?.created || result.details?.updated) {
+                    await this.fileManager.writeStatusFiles(rootConfig, {
+                        ...status,
+                        schemaVersion: '1.1',
+                        syncMetadata: {
+                            ...status.syncMetadata,
+                            githubIssueId: result.details.issueId ?? status.syncMetadata.githubIssueId,
+                            githubIssueUrl: result.details.url ?? status.syncMetadata.githubIssueUrl,
+                            published: {
+                                ...(status.syncMetadata.published ?? {}),
+                                githubIssueBodySha256: bodyHash
+                            }
+                        }
+                    });
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                results.push({
+                    target: 'github',
+                    success: false,
+                    timestamp: new Date().toISOString(),
+                    duration: Date.now() - started,
+                    error: { message, recoverable: !config.failHard }
+                });
+                if (config.failHard)
+                    throw error;
+            }
+        }
+        if (actualTargets.includes('obsidian') && config.obsidian?.enabled) {
+            const started = Date.now();
+            try {
+                const available = this.isObsidianAvailable ? await this.isObsidianAvailable() : await obsidian_cli_client_1.ObsidianCliClient.isAvailable();
+                if (!available)
+                    throw new Error('obsidian CLI not available');
+                const syncer = this.createObsidianSyncer
+                    ? this.createObsidianSyncer(config.obsidian)
+                    : new obsidian_sync_adapter_1.ObsidianSyncAdapter(config.obsidian, new obsidian_cli_client_1.ObsidianCliClient());
+                const result = await syncer.sync(status, reentryMarkdown);
+                results.push(result);
+                const contentHash = (0, dirty_detection_1.sha256)(syncer.renderNoteContent(status, reentryMarkdown));
+                if (result.details?.updated) {
+                    await this.fileManager.writeStatusFiles(rootConfig, {
+                        ...status,
+                        schemaVersion: '1.1',
+                        syncMetadata: {
+                            ...status.syncMetadata,
+                            obsidianNotePath: config.obsidian.notePath,
+                            published: {
+                                ...(status.syncMetadata.published ?? {}),
+                                obsidianNoteBodySha256: contentHash
+                            }
+                        }
+                    });
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                results.push({
+                    target: 'obsidian',
+                    success: false,
+                    timestamp: new Date().toISOString(),
+                    duration: Date.now() - started,
+                    error: { message, recoverable: !config.failHard }
+                });
+                if (config.failHard)
+                    throw error;
+            }
+        }
+        return results;
+    }
+}
+exports.ReentryStatusManager = ReentryStatusManager;
+//# sourceMappingURL=reentry-status-manager.js.map

package/dist/extensions/reentry-status/roadmap-parser.d.ts

@@ -0,0 +1,13 @@
+export interface RoadmapMilestoneItem {
+    id: string;
+    title: string;
+    section?: string;
+    line: number;
+}
+export declare const ROADMAP_ITEM_REGEX: RegExp;
+export interface ParseRoadmapResult {
+    items: RoadmapMilestoneItem[];
+    warnings: string[];
+}
+export declare function parseRoadmapMilestones(markdown: string): ParseRoadmapResult;
+//# sourceMappingURL=roadmap-parser.d.ts.map

package/dist/extensions/reentry-status/roadmap-parser.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROADMAP_ITEM_REGEX = void 0;
+exports.parseRoadmapMilestones = parseRoadmapMilestones;
+exports.ROADMAP_ITEM_REGEX = /^\s*-\s*\[(.+?)\]\s*(.+)$/;
+function parseRoadmapMilestones(markdown) {
+    const normalized = markdown.replace(/\r\n/g, '\n');
+    const lines = normalized.split('\n');
+    const items = [];
+    const warnings = [];
+    let currentSection;
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        const h2 = /^##\s+(.+?)\s*$/.exec(line);
+        if (h2) {
+            currentSection = h2[1];
+            continue;
+        }
+        const match = exports.ROADMAP_ITEM_REGEX.exec(line);
+        if (!match)
+            continue;
+        const id = match[1].trim();
+        const title = match[2].trim();
+        if (!id || !title) {
+            warnings.push(`Invalid roadmap item at line ${i + 1}`);
+            continue;
+        }
+        items.push({ id, title, section: currentSection, line: i + 1 });
+    }
+    return { items, warnings };
+}
+//# sourceMappingURL=roadmap-parser.js.map

package/dist/extensions/reentry-status/roadmap-renderer.d.ts

@@ -0,0 +1,19 @@
+import { ReentryStatus } from './models';
+export declare const ROADMAP_MANAGED_START = "<!-- roadmap:managed:start -->";
+export declare const ROADMAP_MANAGED_END = "<!-- roadmap:managed:end -->";
+export interface RoadmapRenderOptions {
+    projectTitle?: string;
+}
+export declare class RoadmapRenderer {
+    static defaultRoadmapPath(baseDir?: string): string;
+    static renderManagedBlock(status?: Pick<ReentryStatus, 'milestone' | 'roadmapFile'>): string;
+    static renderTemplate(options?: RoadmapRenderOptions, status?: Pick<ReentryStatus, 'milestone' | 'roadmapFile'>): string;
+    /**
+     * Inserts or updates the managed header block without touching user content.
+     */
+    static upsertManagedBlock(existing: string, status?: Pick<ReentryStatus, 'milestone' | 'roadmapFile'>): {
+        content: string;
+        changed: boolean;
+    };
+}
+//# sourceMappingURL=roadmap-renderer.d.ts.map

package/dist/extensions/reentry-status/roadmap-renderer.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoadmapRenderer = exports.ROADMAP_MANAGED_END = exports.ROADMAP_MANAGED_START = void 0;
+const constants_1 = require("./constants");
+exports.ROADMAP_MANAGED_START = '<!-- roadmap:managed:start -->';
+exports.ROADMAP_MANAGED_END = '<!-- roadmap:managed:end -->';
+class RoadmapRenderer {
+    static defaultRoadmapPath(baseDir = constants_1.REENTRY_STATUS_DIRNAME) {
+        return `${baseDir}/${constants_1.ROADMAP_MD_FILENAME}`;
+    }
+    static renderManagedBlock(status) {
+        const milestoneText = status?.milestone
+            ? `${status.milestone.title} (id: ${status.milestone.id})`
+            : '—';
+        const roadmapFile = status?.roadmapFile ?? RoadmapRenderer.defaultRoadmapPath();
+        // Keep this block stable: no timestamps.
+        return [
+            exports.ROADMAP_MANAGED_START,
+            '> Managed by `@edcalderon/versioning` reentry-status-extension.',
+            `> Canonical roadmap file: ${roadmapFile}`,
+            `> Active milestone: ${milestoneText}`,
+            '> ',
+            '> Everything outside this block is user-editable.',
+            exports.ROADMAP_MANAGED_END,
+            ''
+        ].join('\n');
+    }
+    static renderTemplate(options = {}, status) {
+        const title = options.projectTitle?.trim() ? options.projectTitle.trim() : 'Untitled';
+        return [
+            `# Project Roadmap – ${title}`,
+            '',
+            RoadmapRenderer.renderManagedBlock(status),
+            '## North Star',
+            '',
+            '- Describe the long-term outcome this project is aiming for.',
+            '',
+            '## Now (1–2 weeks)',
+            '',
+            '- [now-01] Example: Ship X',
+            '',
+            '## Next (4–8 weeks)',
+            '',
+            '- [next-01] Example: Improve Y',
+            '',
+            '## Later',
+            '',
+            '- [later-01] Example: Explore Z',
+            ''
+        ].join('\n');
+    }
+    /**
+     * Inserts or updates the managed header block without touching user content.
+     */
+    static upsertManagedBlock(existing, status) {
+        const managed = RoadmapRenderer.renderManagedBlock(status);
+        const input = existing.replace(/\r\n/g, '\n');
+        const startIdx = input.indexOf(exports.ROADMAP_MANAGED_START);
+        const endIdx = input.indexOf(exports.ROADMAP_MANAGED_END);
+        if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+            const endAfter = endIdx + exports.ROADMAP_MANAGED_END.length;
+            const before = input.slice(0, startIdx);
+            const after = input.slice(endAfter);
+            let afterNormalized = after;
+            if (managed.endsWith('\n') && afterNormalized.startsWith('\n')) {
+                // Prevent accidental extra blank line when swapping the managed block.
+                afterNormalized = afterNormalized.slice(1);
+            }
+            const next = `${before}${managed}${afterNormalized}`;
+            return { content: next, changed: next !== input };
+        }
+        // No managed block yet: insert right after the first H1 if present, otherwise at top.
+        const lines = input.split('\n');
+        const h1Index = lines.findIndex((l) => /^#\s+/.test(l));
+        if (h1Index !== -1) {
+            const insertAt = h1Index + 1;
+            const nextLines = [...lines];
+            // Ensure a blank line after H1.
+            if (nextLines[insertAt] !== '')
+                nextLines.splice(insertAt, 0, '');
+            // Insert managed block after that blank line.
+            const afterBlank = insertAt + 1;
+            nextLines.splice(afterBlank, 0, managed.trimEnd());
+            const next = `${nextLines.join('\n').replace(/\n{3,}/g, '\n\n')}\n`;
+            return { content: next, changed: next !== `${input}${input.endsWith('\n') ? '' : '\n'}` };
+        }
+        const next = `${managed}${input.replace(/^\n+/, '')}`;
+        return { content: next, changed: next !== input };
+    }
+}
+exports.RoadmapRenderer = RoadmapRenderer;
+//# sourceMappingURL=roadmap-renderer.js.map

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

@@ -0,0 +1,10 @@
+import { ReentryStatus } from './models';
+export declare class StatusRenderer {
+    static defaultReentryMarkdownPath(): string;
+    static defaultRoadmapPath(): string;
+    static parseJson(json: string): ReentryStatus;
+    static renderJson(status: ReentryStatus): string;
+    static renderMarkdown(status: ReentryStatus): string;
+    static parseMarkdown(_markdown: string): Partial<ReentryStatus>;
+}
+//# sourceMappingURL=status-renderer.d.ts.map

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

@@ -0,0 +1,176 @@
+"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.StatusRenderer = void 0;
+const path = __importStar(require("path"));
+const constants_1 = require("./constants");
+const roadmap_renderer_1 = require("./roadmap-renderer");
+function sortKeysDeep(value) {
+    if (Array.isArray(value))
+        return value.map(sortKeysDeep);
+    if (value && typeof value === 'object') {
+        const obj = value;
+        const sorted = {};
+        for (const key of Object.keys(obj).sort()) {
+            const child = obj[key];
+            if (child === undefined)
+                continue;
+            sorted[key] = sortKeysDeep(child);
+        }
+        return sorted;
+    }
+    return value;
+}
+function nonEmptyStringOr(value, fallback) {
+    return typeof value === 'string' && value.trim().length > 0 ? value : fallback;
+}
+class StatusRenderer {
+    static defaultReentryMarkdownPath() {
+        return path.join(constants_1.REENTRY_STATUS_DIRNAME, constants_1.REENTRY_STATUS_MD_FILENAME);
+    }
+    static defaultRoadmapPath() {
+        return roadmap_renderer_1.RoadmapRenderer.defaultRoadmapPath();
+    }
+    static parseJson(json) {
+        const raw = JSON.parse(json);
+        const schemaVersion = raw.schemaVersion === '1.1' ? '1.1' : '1.0';
+        const milestone = raw.milestone && typeof raw.milestone === 'object' && typeof raw.milestone.id === 'string'
+            ? { id: String(raw.milestone.id), title: nonEmptyStringOr(raw.milestone.title, String(raw.milestone.id)) }
+            : null;
+        const roadmapFile = nonEmptyStringOr(raw.roadmapFile, StatusRenderer.defaultRoadmapPath());
+        // Normalize missing structures to safe defaults (v1.0 compatibility).
+        const normalized = {
+            schemaVersion,
+            version: nonEmptyStringOr(raw.version, '0.0.0'),
+            lastUpdated: nonEmptyStringOr(raw.lastUpdated, new Date(0).toISOString()),
+            updatedBy: nonEmptyStringOr(raw.updatedBy, 'unknown'),
+            context: raw.context ?? {
+                trigger: 'manual',
+                gitInfo: { branch: '', commit: '', author: '', timestamp: new Date(0).toISOString() },
+                versioningInfo: {}
+            },
+            milestone,
+            roadmapFile,
+            currentPhase: raw.currentPhase ?? 'planning',
+            milestones: Array.isArray(raw.milestones) ? raw.milestones : [],
+            blockers: Array.isArray(raw.blockers) ? raw.blockers : [],
+            nextSteps: Array.isArray(raw.nextSteps) ? raw.nextSteps : [],
+            risks: Array.isArray(raw.risks) ? raw.risks : [],
+            dependencies: Array.isArray(raw.dependencies) ? raw.dependencies : [],
+            versioning: raw.versioning ?? {
+                currentVersion: '',
+                previousVersion: '',
+                versionType: 'patch'
+            },
+            syncMetadata: raw.syncMetadata ?? {
+                lastSyncAttempt: new Date(0).toISOString(),
+                lastSuccessfulSync: new Date(0).toISOString()
+            }
+        };
+        // Ensure new nested optional objects exist only when needed; do not force migration writes.
+        return normalized;
+    }
+    static renderJson(status) {
+        const stable = sortKeysDeep(status);
+        return `${JSON.stringify(stable, null, 2)}\n`;
+    }
+    static renderMarkdown(status) {
+        const milestoneText = status.milestone
+            ? `${status.milestone.title} (id: ${status.milestone.id})`
+            : '—';
+        const nextMicroStep = status.nextSteps?.[0]?.description ?? '—';
+        return [
+            '# Re-entry Status',
+            '',
+            `Schema: ${status.schemaVersion}`,
+            `Version: ${status.version}`,
+            `Phase: ${status.currentPhase}`,
+            '',
+            `Next micro-step: ${nextMicroStep}`,
+            '',
+            `Milestone: ${milestoneText}`,
+            `Roadmap: ${status.roadmapFile || StatusRenderer.defaultRoadmapPath()}`,
+            '',
+            '## Notes',
+            '',
+            '- This file is generated for stable diffs. Edit ROADMAP.md for long-term planning.',
+            ''
+        ].join('\n');
+    }
+    static parseMarkdown(_markdown) {
+        const markdown = _markdown.replace(/\r\n/g, '\n');
+        const out = {};
+        const schema = /^Schema:[ \t]*([^\n\r]*)$/m.exec(markdown);
+        if (schema)
+            out.schemaVersion = schema[1].trim();
+        const version = /^Version:[ \t]*([^\n\r]*)$/m.exec(markdown);
+        if (version)
+            out.version = version[1].trim();
+        const phase = /^Phase:[ \t]*([^\n\r]*)$/m.exec(markdown);
+        if (phase)
+            out.currentPhase = phase[1].trim();
+        const next = /^Next micro-step:[ \t]*([^\n\r]*)$/m.exec(markdown);
+        if (next) {
+            const desc = next[1].trim();
+            if (desc && desc !== '—')
+                out.nextSteps = [{ id: 'next', description: desc, priority: 1 }];
+        }
+        const roadmap = /^Roadmap:[ \t]*([^\n\r]*)$/m.exec(markdown);
+        if (roadmap)
+            out.roadmapFile = roadmap[1].trim();
+        const milestone = /^Milestone:[ \t]*([^\n\r]*)$/m.exec(markdown);
+        if (milestone) {
+            const text = milestone[1].trim();
+            if (!text || text === '—') {
+                out.milestone = null;
+            }
+            else {
+                const markers = [' (id: ', '(id: '];
+                const marker = markers.find((m) => text.includes(m));
+                if (!marker)
+                    return out;
+                const markerIndex = text.lastIndexOf(marker);
+                if (markerIndex !== -1 && text.endsWith(')')) {
+                    const title = text.slice(0, markerIndex).trim();
+                    const id = text.slice(markerIndex + marker.length, -1).trim();
+                    out.milestone = { title, id };
+                }
+            }
+        }
+        return out;
+    }
+}
+exports.StatusRenderer = StatusRenderer;
+//# sourceMappingURL=status-renderer.js.map

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

@@ -0,0 +1,4 @@
+import { VersioningExtension } from '../extensions';
+declare const extension: VersioningExtension;
+export default extension;
+//# sourceMappingURL=reentry-status-extension.d.ts.map