@edcalderon/versioning 1.0.11 → 1.1.2

package/dist/extensions/reentry-status/github-sync-adapter.d.ts

@@ -0,0 +1,39 @@
+import { GitHubConfig, ReentryStatus, SyncResult } from './models';
+export interface GitHubIssue {
+    id: number;
+    url: string;
+    title: string;
+    body: string;
+}
+export interface GitHubClient {
+    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>;
+}
+export declare class GitHubSyncAdapter {
+    private readonly config;
+    private readonly client;
+    constructor(config: GitHubConfig, client: GitHubClient);
+    renderIssueBody(status: ReentryStatus, reentryMarkdown: string): string;
+    sync(status: ReentryStatus, reentryMarkdown: string): Promise<SyncResult>;
+}
+//# sourceMappingURL=github-sync-adapter.d.ts.map

package/dist/extensions/reentry-status/github-sync-adapter.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHubSyncAdapter = void 0;
+const dirty_detection_1 = require("./dirty-detection");
+class GitHubSyncAdapter {
+    constructor(config, client) {
+        this.config = config;
+        this.client = client;
+    }
+    renderIssueBody(status, reentryMarkdown) {
+        // Keep content stable; rely on upstream renderer for milestone + roadmap.
+        // Avoid adding timestamps.
+        const header = `# Re-entry Status (living)\n\n`;
+        return `${header}${reentryMarkdown}`;
+    }
+    async sync(status, reentryMarkdown) {
+        const started = Date.now();
+        const timestamp = new Date().toISOString();
+        const body = this.renderIssueBody(status, reentryMarkdown);
+        const bodyHash = (0, dirty_detection_1.sha256)(body);
+        const lastPublishedHash = status.syncMetadata.published?.githubIssueBodySha256;
+        if (lastPublishedHash && lastPublishedHash === bodyHash) {
+            return {
+                target: 'github',
+                success: true,
+                timestamp,
+                duration: Date.now() - started,
+                details: { skipped: true, reason: 'unchanged (hash)' }
+            };
+        }
+        const existing = await this.client.findIssueByTitle({
+            owner: this.config.owner,
+            repo: this.config.repo,
+            title: this.config.issue.title
+        });
+        if (existing) {
+            if ((0, dirty_detection_1.bodiesEqual)(existing.body, body)) {
+                return {
+                    target: 'github',
+                    success: true,
+                    timestamp,
+                    duration: Date.now() - started,
+                    details: { skipped: true, reason: 'unchanged (body)' }
+                };
+            }
+            await this.client.updateIssue({
+                owner: this.config.owner,
+                repo: this.config.repo,
+                issueId: existing.id,
+                body,
+                labels: this.config.issue.labels,
+                assignees: this.config.issue.assignees
+            });
+            return {
+                target: 'github',
+                success: true,
+                timestamp,
+                duration: Date.now() - started,
+                details: { updated: true, issueId: existing.id, url: existing.url, bodyHash }
+            };
+        }
+        const created = await this.client.createIssue({
+            owner: this.config.owner,
+            repo: this.config.repo,
+            title: this.config.issue.title,
+            body,
+            labels: this.config.issue.labels,
+            assignees: this.config.issue.assignees
+        });
+        return {
+            target: 'github',
+            success: true,
+            timestamp,
+            duration: Date.now() - started,
+            details: { created: true, issueId: created.id, url: created.url, bodyHash }
+        };
+    }
+}
+exports.GitHubSyncAdapter = GitHubSyncAdapter;
+//# sourceMappingURL=github-sync-adapter.js.map

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

@@ -0,0 +1,14 @@
+export * from './constants';
+export * from './config-manager';
+export * from './dirty-detection';
+export * from './file-manager';
+export * from './github-sync-adapter';
+export * from './github-rest-client';
+export * from './models';
+export * from './obsidian-sync-adapter';
+export * from './obsidian-cli-client';
+export * from './roadmap-parser';
+export * from './roadmap-renderer';
+export * from './reentry-status-manager';
+export * from './status-renderer';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,30 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants"), exports);
+__exportStar(require("./config-manager"), exports);
+__exportStar(require("./dirty-detection"), exports);
+__exportStar(require("./file-manager"), exports);
+__exportStar(require("./github-sync-adapter"), exports);
+__exportStar(require("./github-rest-client"), exports);
+__exportStar(require("./models"), exports);
+__exportStar(require("./obsidian-sync-adapter"), exports);
+__exportStar(require("./obsidian-cli-client"), exports);
+__exportStar(require("./roadmap-parser"), exports);
+__exportStar(require("./roadmap-renderer"), exports);
+__exportStar(require("./reentry-status-manager"), exports);
+__exportStar(require("./status-renderer"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,159 @@
+export type ProjectPhase = 'planning' | 'development' | 'testing' | 'staging' | 'production' | 'maintenance';
+export type SyncTarget = 'files' | 'github' | 'obsidian';
+export type ReentrySchemaVersion = '1.0' | '1.1';
+export interface ReentryMilestoneLink {
+    id: string;
+    title: string;
+}
+export interface UpdateContext {
+    trigger: 'manual' | 'postVersion' | 'postRelease' | 'auto';
+    command?: string;
+    options?: any;
+    gitInfo: {
+        branch: string;
+        commit: string;
+        author: string;
+        timestamp: string;
+    };
+    versioningInfo: {
+        versionType?: string;
+        oldVersion?: string;
+        newVersion?: string;
+    };
+}
+export interface Milestone {
+    id: string;
+    title: string;
+    description: string;
+    status: 'pending' | 'in-progress' | 'completed' | 'blocked';
+    dueDate?: string;
+    completedDate?: string;
+}
+export interface Blocker {
+    id: string;
+    description: string;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    assignedTo?: string;
+    created: string;
+    resolved?: boolean;
+    resolutionDate?: string;
+}
+export interface NextStep {
+    id: string;
+    description: string;
+    priority: number;
+    estimatedEffort?: string;
+    dependencies?: string[];
+}
+export interface Risk {
+    id: string;
+    description: string;
+    probability: 'low' | 'medium' | 'high';
+    impact: 'low' | 'medium' | 'high';
+    mitigation: string;
+}
+export interface Dependency {
+    id: string;
+    name: string;
+    type: 'internal' | 'external' | 'service';
+    status: 'healthy' | 'degraded' | 'down';
+    version?: string;
+}
+export interface ReentryStatus {
+    schemaVersion: ReentrySchemaVersion;
+    version: string;
+    lastUpdated: string;
+    updatedBy: string;
+    context: UpdateContext;
+    milestone: ReentryMilestoneLink | null;
+    roadmapFile: string;
+    currentPhase: ProjectPhase;
+    milestones: Milestone[];
+    blockers: Blocker[];
+    nextSteps: NextStep[];
+    risks: Risk[];
+    dependencies: Dependency[];
+    versioning: {
+        currentVersion: string;
+        previousVersion: string;
+        versionType: 'patch' | 'minor' | 'major';
+        releaseDate?: string;
+    };
+    syncMetadata: {
+        githubIssueId?: number;
+        githubIssueUrl?: string;
+        obsidianNotePath?: string;
+        lastSyncAttempt: string;
+        lastSuccessfulSync: string;
+        published?: {
+            githubIssueBodySha256?: string;
+            obsidianNoteBodySha256?: string;
+        };
+    };
+}
+export interface GitHubConfig {
+    enabled: boolean;
+    owner: string;
+    repo: string;
+    issue: {
+        title: string;
+        labels: string[];
+        assignees?: string[];
+        template?: string;
+    };
+    auth: {
+        token: string;
+    };
+}
+export interface ObsidianConfig {
+    enabled: boolean;
+    vaultPath: string;
+    notePath: string;
+    template?: string;
+    frontmatter?: Record<string, any>;
+}
+export interface CustomSection {
+    id: string;
+    title: string;
+    renderer: (status: ReentryStatus) => string;
+}
+export interface ReentryStatusConfig {
+    enabled: boolean;
+    autoSync: boolean;
+    failHard: boolean;
+    hooks?: {
+        postVersion?: boolean;
+        postRelease?: boolean;
+    };
+    files: {
+        jsonPath: string;
+        markdownPath: string;
+    };
+    github?: GitHubConfig;
+    obsidian?: ObsidianConfig;
+    template?: {
+        includeSections: string[];
+        excludeSections: string[];
+        customSections?: CustomSection[];
+    };
+}
+export interface SyncResult {
+    target: SyncTarget;
+    success: boolean;
+    timestamp: string;
+    duration: number;
+    details?: any;
+    error?: {
+        message: string;
+        code?: string;
+        recoverable: boolean;
+    };
+}
+export interface ErrorContext {
+    operation: string;
+    component: string;
+    severity: 'warning' | 'error' | 'fatal';
+    recoverable: boolean;
+    userAction?: string;
+}
+//# sourceMappingURL=models.d.ts.map

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=models.js.map

package/dist/extensions/reentry-status/obsidian-cli-client.d.ts

@@ -0,0 +1,15 @@
+import { ObsidianClient, ObsidianNote } from './obsidian-sync-adapter';
+export declare class ObsidianCliClient implements ObsidianClient {
+    getNote(params: {
+        vaultPath: string;
+        notePath: string;
+    }): Promise<ObsidianNote | null>;
+    upsertNote(params: {
+        vaultPath: string;
+        notePath: string;
+        content: string;
+    }): Promise<ObsidianNote>;
+    static isAvailable(): Promise<boolean>;
+    static normalizeVaultPath(vaultPath: string): string;
+}
+//# sourceMappingURL=obsidian-cli-client.d.ts.map

package/dist/extensions/reentry-status/obsidian-cli-client.js

@@ -0,0 +1,96 @@
+"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.ObsidianCliClient = void 0;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+function escapeCliValue(value) {
+    // Obsidian CLI expects newlines escaped as \n.
+    return value.replace(/\r\n/g, '\n').replace(/\n/g, '\\n');
+}
+async function runObsidian(args, cwd) {
+    return await new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)('obsidian', args, {
+            cwd,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (d) => (stdout += String(d)));
+        child.stderr.on('data', (d) => (stderr += String(d)));
+        child.on('error', (err) => reject(err));
+        child.on('close', (code) => {
+            if (code === 0)
+                return resolve(stdout);
+            reject(new Error(`obsidian CLI failed (code ${code}): ${stderr || stdout}`));
+        });
+    });
+}
+class ObsidianCliClient {
+    async getNote(params) {
+        const cwd = params.vaultPath;
+        const notePath = params.notePath;
+        try {
+            const output = await runObsidian([`read`, `path=${notePath}`], cwd);
+            // CLI prints the file contents.
+            return { path: notePath, content: output };
+        }
+        catch {
+            return null;
+        }
+    }
+    async upsertNote(params) {
+        const cwd = params.vaultPath;
+        const notePath = params.notePath;
+        // Obsidian CLI `create` can overwrite with the `overwrite` flag.
+        const content = escapeCliValue(params.content);
+        await runObsidian([`create`, `path=${notePath}`, `content=${content}`, 'overwrite', 'silent'], cwd);
+        return { path: notePath, content: params.content };
+    }
+    static async isAvailable() {
+        try {
+            await runObsidian(['version']);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    static normalizeVaultPath(vaultPath) {
+        return path.resolve(vaultPath);
+    }
+}
+exports.ObsidianCliClient = ObsidianCliClient;
+//# sourceMappingURL=obsidian-cli-client.js.map

package/dist/extensions/reentry-status/obsidian-sync-adapter.d.ts

@@ -0,0 +1,24 @@
+import { ObsidianConfig, ReentryStatus, SyncResult } from './models';
+export interface ObsidianNote {
+    path: string;
+    content: string;
+}
+export interface ObsidianClient {
+    getNote(params: {
+        vaultPath: string;
+        notePath: string;
+    }): Promise<ObsidianNote | null>;
+    upsertNote(params: {
+        vaultPath: string;
+        notePath: string;
+        content: string;
+    }): Promise<ObsidianNote>;
+}
+export declare class ObsidianSyncAdapter {
+    private readonly config;
+    private readonly client;
+    constructor(config: ObsidianConfig, client: ObsidianClient);
+    renderNoteContent(status: ReentryStatus, reentryMarkdown: string): string;
+    sync(status: ReentryStatus, reentryMarkdown: string): Promise<SyncResult>;
+}
+//# sourceMappingURL=obsidian-sync-adapter.d.ts.map

package/dist/extensions/reentry-status/obsidian-sync-adapter.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObsidianSyncAdapter = void 0;
+const dirty_detection_1 = require("./dirty-detection");
+class ObsidianSyncAdapter {
+    constructor(config, client) {
+        this.config = config;
+        this.client = client;
+    }
+    renderNoteContent(status, reentryMarkdown) {
+        const fm = this.config.frontmatter;
+        if (!fm || Object.keys(fm).length === 0)
+            return reentryMarkdown;
+        const lines = ['---'];
+        for (const key of Object.keys(fm).sort()) {
+            const value = fm[key];
+            if (value === undefined)
+                continue;
+            if (Array.isArray(value)) {
+                lines.push(`${key}:`);
+                for (const item of value)
+                    lines.push(`  - ${String(item)}`);
+                continue;
+            }
+            if (value && typeof value === 'object') {
+                // Keep it simple: embed JSON for nested objects.
+                lines.push(`${key}: ${JSON.stringify(value)}`);
+                continue;
+            }
+            lines.push(`${key}: ${String(value)}`);
+        }
+        lines.push('---', '');
+        // Keep deterministic: do not add timestamps.
+        // Also include roadmap pointer and milestone info (already present in REENTRY.md).
+        return `${lines.join('\n')}${reentryMarkdown}`;
+    }
+    async sync(status, reentryMarkdown) {
+        const started = Date.now();
+        const timestamp = new Date().toISOString();
+        const content = this.renderNoteContent(status, reentryMarkdown);
+        const contentHash = (0, dirty_detection_1.sha256)(content);
+        const lastPublishedHash = status.syncMetadata.published?.obsidianNoteBodySha256;
+        if (lastPublishedHash && lastPublishedHash === contentHash) {
+            return {
+                target: 'obsidian',
+                success: true,
+                timestamp,
+                duration: Date.now() - started,
+                details: { skipped: true, reason: 'unchanged (hash)' }
+            };
+        }
+        const existing = await this.client.getNote({
+            vaultPath: this.config.vaultPath,
+            notePath: this.config.notePath
+        });
+        if (existing && (0, dirty_detection_1.bodiesEqual)(existing.content, content)) {
+            return {
+                target: 'obsidian',
+                success: true,
+                timestamp,
+                duration: Date.now() - started,
+                details: { skipped: true, reason: 'unchanged (content)' }
+            };
+        }
+        await this.client.upsertNote({
+            vaultPath: this.config.vaultPath,
+            notePath: this.config.notePath,
+            content
+        });
+        return {
+            target: 'obsidian',
+            success: true,
+            timestamp,
+            duration: Date.now() - started,
+            details: { updated: true, notePath: this.config.notePath, contentHash }
+        };
+    }
+}
+exports.ObsidianSyncAdapter = ObsidianSyncAdapter;
+//# sourceMappingURL=obsidian-sync-adapter.js.map

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

@@ -0,0 +1,30 @@
+import { FileManager } from './file-manager';
+import { GitHubConfig, ObsidianConfig, ReentryStatus, SyncResult, SyncTarget, UpdateContext } from './models';
+export interface GitHubSyncer {
+    renderIssueBody(status: ReentryStatus, reentryMarkdown: string): string;
+    sync(status: ReentryStatus, reentryMarkdown: string): Promise<SyncResult>;
+}
+export interface ObsidianSyncer {
+    renderNoteContent(status: ReentryStatus, reentryMarkdown: string): string;
+    sync(status: ReentryStatus, reentryMarkdown: string): Promise<SyncResult>;
+}
+export interface ReentryStatusManagerOptions {
+    fileManager?: FileManager;
+    createGitHubSyncer?: (config: GitHubConfig) => GitHubSyncer;
+    createObsidianSyncer?: (config: ObsidianConfig) => ObsidianSyncer;
+    isObsidianAvailable?: () => Promise<boolean>;
+}
+export declare class ReentryStatusManager {
+    private readonly fileManager;
+    private readonly createGitHubSyncer?;
+    private readonly createObsidianSyncer?;
+    private readonly isObsidianAvailable?;
+    constructor(options?: ReentryStatusManagerOptions);
+    createInitialStatus(): ReentryStatus;
+    loadOrInit(rootConfig: any): Promise<ReentryStatus>;
+    updateStatus(rootConfig: any, updater: (current: ReentryStatus) => ReentryStatus): Promise<ReentryStatus>;
+    applyContext(rootConfig: any, context: UpdateContext): Promise<ReentryStatus>;
+    ensureRoadmapExists(rootConfig: any, status: ReentryStatus): Promise<void>;
+    syncAll(rootConfig: any, targets?: SyncTarget[]): Promise<SyncResult[]>;
+}
+//# sourceMappingURL=reentry-status-manager.d.ts.map