@edcalderon/versioning 1.1.0 → 1.2.0

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

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
 const config_manager_1 = require("./reentry-status/config-manager");
 const constants_1 = require("./reentry-status/constants");
 const file_manager_1 = require("./reentry-status/file-manager");
@@ -47,14 +48,14 @@ const roadmap_parser_1 = require("./reentry-status/roadmap-parser");
 const roadmap_renderer_1 = require("./reentry-status/roadmap-renderer");
 const status_renderer_1 = require("./reentry-status/status-renderer");
 const reentry_status_manager_1 = require("./reentry-status/reentry-status-manager");
+const git_context_1 = require("./reentry-status/git-context");
 const extension = {
     name: constants_1.REENTRY_EXTENSION_NAME,
     description: 'Maintains canonical re-entry status and synchronizes to files, GitHub Issues, and Obsidian notes',
-    version: '1.1.0',
+    version: '1.2.0',
     hooks: {
         postVersion: async (type, version, options) => {
             try {
-                // Extensions are loaded before the CLI reads config per-command; use global config snapshot.
                 const configPath = options?.config ?? 'versioning.config.json';
                 if (!(await fs.pathExists(configPath)))
                     return;
@@ -64,15 +65,42 @@ const extension = {
                     return;
                 if (reentryCfg.hooks?.postVersion === false)
                     return;
+                // Auto-collect real git context
+                const gitCtx = await (0, git_context_1.collectGitContext)();
                 const manager = new reentry_status_manager_1.ReentryStatusManager({ fileManager: new file_manager_1.FileManager() });
                 await manager.applyContext(cfg, {
                     trigger: 'postVersion',
                     command: 'versioning bump',
                     options,
-                    gitInfo: { branch: '', commit: '', author: '', timestamp: new Date().toISOString() },
+                    gitInfo: {
+                        branch: gitCtx.branch,
+                        commit: gitCtx.commit,
+                        author: gitCtx.author,
+                        timestamp: gitCtx.timestamp,
+                    },
                     versioningInfo: { versionType: type, oldVersion: undefined, newVersion: version }
                 });
+                // Auto-update phase and suggest next step
+                const current = await manager.loadOrInit(cfg);
+                const phase = (0, git_context_1.inferPhase)(gitCtx, version);
+                const nextStep = (0, git_context_1.suggestNextStep)(gitCtx);
+                const updated = {
+                    ...current,
+                    schemaVersion: '1.1',
+                    currentPhase: phase,
+                    nextSteps: [{ id: 'next', description: nextStep, priority: 1 }],
+                    version: version,
+                    versioning: {
+                        ...current.versioning,
+                        currentVersion: version,
+                        previousVersion: current.versioning.currentVersion,
+                        versionType: type,
+                    },
+                    lastUpdated: new Date().toISOString(),
+                };
+                await manager.updateStatus(cfg, () => updated);
                 await manager.syncAll(cfg);
+                console.log(`📋 Re-entry auto-updated: phase=${phase}, next="${nextStep}"`);
             }
             catch (error) {
                 console.warn('⚠️  reentry-status postVersion hook failed:', error instanceof Error ? error.message : String(error));
@@ -89,12 +117,19 @@ const extension = {
                     return;
                 if (reentryCfg.hooks?.postRelease !== true)
                     return;
+                // Auto-collect real git context
+                const gitCtx = await (0, git_context_1.collectGitContext)();
                 const manager = new reentry_status_manager_1.ReentryStatusManager({ fileManager: new file_manager_1.FileManager() });
                 await manager.applyContext(cfg, {
                     trigger: 'postRelease',
                     command: 'versioning release',
                     options,
-                    gitInfo: { branch: '', commit: '', author: '', timestamp: new Date().toISOString() },
+                    gitInfo: {
+                        branch: gitCtx.branch,
+                        commit: gitCtx.commit,
+                        author: gitCtx.author,
+                        timestamp: gitCtx.timestamp,
+                    },
                     versioningInfo: { newVersion: version }
                 });
                 await manager.syncAll(cfg);
@@ -107,31 +142,122 @@ const extension = {
     register: async (program, rootConfig) => {
         const fileManager = new file_manager_1.FileManager();
         const manager = new reentry_status_manager_1.ReentryStatusManager({ fileManager });
+        const discoverWorkspaceProjects = async (configPath) => {
+            const rootDir = path.dirname(configPath);
+            const slugs = new Set();
+            const names = new Set();
+            const considerPackageJson = async (packageJsonPath) => {
+                try {
+                    if (!(await fs.pathExists(packageJsonPath)))
+                        return;
+                    const pkg = await fs.readJson(packageJsonPath);
+                    const name = typeof pkg?.name === 'string' ? String(pkg.name).trim() : '';
+                    if (!name)
+                        return;
+                    names.add(name);
+                    const slug = name.includes('/') ? name.split('/').pop() : name;
+                    if (slug)
+                        slugs.add(String(slug));
+                }
+                catch {
+                    // ignore
+                }
+            };
+            const scanOneLevel = async (baseDir) => {
+                const abs = path.join(rootDir, baseDir);
+                if (!(await fs.pathExists(abs)))
+                    return;
+                const entries = await fs.readdir(abs, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (!entry.isDirectory())
+                        continue;
+                    const dirName = entry.name;
+                    if (dirName === 'node_modules' || dirName === 'dist' || dirName === '.git' || dirName === 'archive')
+                        continue;
+                    slugs.add(dirName);
+                    await considerPackageJson(path.join(abs, dirName, 'package.json'));
+                }
+            };
+            const scanTwoLevelsUnderApps = async () => {
+                const absApps = path.join(rootDir, 'apps');
+                if (!(await fs.pathExists(absApps)))
+                    return;
+                const entries = await fs.readdir(absApps, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (!entry.isDirectory())
+                        continue;
+                    const groupDir = path.join(absApps, entry.name);
+                    if (entry.name === 'node_modules' || entry.name === 'dist' || entry.name === '.git' || entry.name === 'archive')
+                        continue;
+                    const nested = await fs.readdir(groupDir, { withFileTypes: true });
+                    for (const n of nested) {
+                        if (!n.isDirectory())
+                            continue;
+                        if (n.name === 'node_modules' || n.name === 'dist' || n.name === '.git' || n.name === 'archive')
+                            continue;
+                        slugs.add(n.name);
+                        await considerPackageJson(path.join(groupDir, n.name, 'package.json'));
+                    }
+                }
+            };
+            await scanOneLevel('apps');
+            await scanTwoLevelsUnderApps();
+            await scanOneLevel('packages');
+            return { slugs, names };
+        };
+        const validateProjectOption = async (configPath, project) => {
+            const canonical = (0, config_manager_1.canonicalProjectKey)(project);
+            if (!canonical)
+                return undefined;
+            const { slugs, names } = await discoverWorkspaceProjects(configPath);
+            const raw = String(project ?? '').trim();
+            const ok = slugs.has(canonical) || names.has(raw) || names.has(`@ed/${canonical}`) || names.has(`@edcalderon/${canonical}`);
+            if (!ok) {
+                const available = Array.from(slugs).sort().slice(0, 40);
+                const suffix = slugs.size > 40 ? '…' : '';
+                throw new Error(`Unknown project scope: '${raw}'. Expected an existing workspace app/package (try one of: ${available.join(', ')}${suffix}).`);
+            }
+            return canonical;
+        };
         const loadRootConfigFile = async (configPath) => {
             if (!(await fs.pathExists(configPath))) {
                 throw new Error(`Config file not found: ${configPath}. Run 'versioning init' to create one.`);
             }
             return await fs.readJson(configPath);
         };
-        const ensureReentryInitialized = async (configPath, migrate) => {
-            const cfg = await loadRootConfigFile(configPath);
-            const reentryCfg = config_manager_1.ConfigManager.loadConfig(cfg);
-            await fs.ensureDir(constants_1.REENTRY_STATUS_DIRNAME);
+        const ensureReentryInitialized = async (configPath, migrate, project) => {
+            const validatedProject = await validateProjectOption(configPath, project);
+            const rawCfg = await loadRootConfigFile(configPath);
+            const resolved = config_manager_1.ConfigManager.loadConfig(rawCfg, validatedProject);
+            const cfg = {
+                ...rawCfg,
+                reentryStatus: {
+                    ...(rawCfg.reentryStatus ?? {}),
+                    files: resolved.files,
+                },
+            };
+            const reentryCfg = config_manager_1.ConfigManager.loadConfig(cfg, validatedProject);
+            await fs.ensureDir(path.dirname(reentryCfg.files.jsonPath));
+            const defaultRoadmapPath = path.join(path.dirname(reentryCfg.files.jsonPath), constants_1.ROADMAP_MD_FILENAME);
             const existingJson = await fileManager.readFileIfExists(reentryCfg.files.jsonPath);
             if (existingJson) {
                 const parsed = status_renderer_1.StatusRenderer.parseJson(existingJson);
                 if (migrate && parsed.schemaVersion === '1.0') {
-                    // Explicit migration: rewrite as 1.1 without changing semantics.
                     const migrated = {
                         ...parsed,
                         schemaVersion: '1.1',
                         milestone: parsed.milestone ?? null,
-                        roadmapFile: parsed.roadmapFile || roadmap_renderer_1.RoadmapRenderer.defaultRoadmapPath()
+                        roadmapFile: defaultRoadmapPath
                     };
                     await fileManager.writeStatusJson(cfg, migrated);
-                    return migrated;
+                    return { cfg, status: migrated };
                 }
-                return parsed;
+                const normalized = {
+                    ...parsed,
+                    schemaVersion: '1.1',
+                    roadmapFile: parsed.roadmapFile || defaultRoadmapPath,
+                };
+                return { cfg, status: normalized };
             }
             const initial = {
                 schemaVersion: '1.1',
@@ -144,7 +270,7 @@ const extension = {
                     versioningInfo: {}
                 },
                 milestone: null,
-                roadmapFile: roadmap_renderer_1.RoadmapRenderer.defaultRoadmapPath(),
+                roadmapFile: defaultRoadmapPath,
                 currentPhase: 'planning',
                 milestones: [],
                 blockers: [],
@@ -162,17 +288,21 @@ const extension = {
                 }
             };
             await fileManager.writeStatusFiles(cfg, initial);
-            return initial;
+            return { cfg, status: initial };
         };
+        // ─────────────────────────────────────────────
+        //  REENTRY COMMANDS
+        // ─────────────────────────────────────────────
         program
             .command('reentry')
             .description('Manage re-entry status (fast layer)')
             .addCommand(new commander_1.Command('init')
             .description('Initialize re-entry status files')
             .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+            .option('-p, --project <name>', 'project scope (separate ROADMAP/REENTRY/status per project)')
             .option('--migrate', 'rewrite v1.0 schema to v1.1 (no semantic changes)', false)
             .action(async (options) => {
-            const status = await ensureReentryInitialized(options.config, Boolean(options.migrate));
+            const { status } = await ensureReentryInitialized(options.config, Boolean(options.migrate), options.project);
             console.log(`✅ Initialized re-entry status (schema ${status.schemaVersion})`);
         }))
             .addCommand(new commander_1.Command('set')
@@ -180,10 +310,10 @@ const extension = {
             .option('--phase <phase>', 'Set current phase')
             .option('--next <text>', 'Set next micro-step (replaces first nextSteps entry)')
             .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+            .option('-p, --project <name>', 'project scope (separate ROADMAP/REENTRY/status per project)')
             .option('--migrate', 'rewrite v1.0 schema to v1.1 (no semantic changes)', false)
             .action(async (options) => {
-            const cfg = await loadRootConfigFile(options.config);
-            const status = await ensureReentryInitialized(options.config, Boolean(options.migrate));
+            const { cfg, status } = await ensureReentryInitialized(options.config, Boolean(options.migrate), options.project);
             const nextStepText = typeof options.next === 'string' ? options.next.trim() : '';
             const phase = typeof options.phase === 'string' ? options.phase.trim() : '';
             const updated = {
@@ -197,15 +327,123 @@ const extension = {
             };
             await manager.updateStatus(cfg, () => updated);
             console.log('✅ Re-entry status updated');
+        }))
+            .addCommand(new commander_1.Command('update')
+            .description('Auto-fill re-entry status from last commit and current version (smart reentry)')
+            .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+            .option('-p, --project <name>', 'project scope')
+            .option('--phase <phase>', 'Override inferred phase')
+            .option('--next <text>', 'Override suggested next step')
+            .option('--dry-run', 'Show what would be updated without writing', false)
+            .action(async (options) => {
+            const { cfg, status } = await ensureReentryInitialized(options.config, false, options.project);
+            // Auto-collect git context
+            const gitCtx = await (0, git_context_1.collectGitContext)();
+            // Read current version from package.json
+            let currentVersion = status.versioning.currentVersion;
+            try {
+                const rootPkg = await fs.readJson('package.json');
+                currentVersion = rootPkg.version || currentVersion;
+            }
+            catch { /* keep existing */ }
+            // Infer phase or use override
+            const phase = options.phase || (0, git_context_1.inferPhase)(gitCtx, currentVersion);
+            // Suggest next step or use override
+            const nextStep = options.next || (0, git_context_1.suggestNextStep)(gitCtx);
+            const updated = {
+                ...status,
+                schemaVersion: '1.1',
+                version: currentVersion,
+                currentPhase: phase,
+                nextSteps: [{ id: 'next', description: nextStep, priority: 1 }],
+                context: {
+                    trigger: 'auto',
+                    command: 'versioning reentry update',
+                    gitInfo: {
+                        branch: gitCtx.branch,
+                        commit: gitCtx.commit,
+                        author: gitCtx.author,
+                        timestamp: gitCtx.timestamp,
+                    },
+                    versioningInfo: {
+                        newVersion: currentVersion,
+                    },
+                },
+                versioning: {
+                    ...status.versioning,
+                    currentVersion: currentVersion,
+                    previousVersion: status.versioning.currentVersion !== currentVersion
+                        ? status.versioning.currentVersion
+                        : status.versioning.previousVersion,
+                },
+                lastUpdated: new Date().toISOString(),
+                updatedBy: gitCtx.author || 'auto',
+            };
+            if (options.dryRun) {
+                console.log('\n📋 Re-entry Update Preview (dry-run)\n');
+                console.log(`  Branch:       ${gitCtx.branch}`);
+                console.log(`  Commit:       ${gitCtx.commit}`);
+                console.log(`  Message:      ${gitCtx.commitMessage}`);
+                console.log(`  Author:       ${gitCtx.author}`);
+                console.log(`  Version:      ${currentVersion}`);
+                console.log(`  Phase:        ${phase}`);
+                console.log(`  Next step:    ${nextStep}`);
+                console.log(`  Files changed: ${gitCtx.diffSummary.filesChanged} (+${gitCtx.diffSummary.insertions}/-${gitCtx.diffSummary.deletions})`);
+                console.log('\n  Use without --dry-run to apply.\n');
+                return;
+            }
+            await manager.updateStatus(cfg, () => updated);
+            console.log('\n📋 Re-entry Status Auto-Updated\n');
+            console.log(`  ├─ Branch:       ${gitCtx.branch}`);
+            console.log(`  ├─ Commit:       ${gitCtx.commit} — ${gitCtx.commitMessage}`);
+            console.log(`  ├─ Version:      ${currentVersion}`);
+            console.log(`  ├─ Phase:        ${phase}`);
+            console.log(`  ├─ Next step:    ${nextStep}`);
+            console.log(`  └─ Updated by:   ${gitCtx.author || 'auto'}\n`);
+            console.log('  🔜 Suggested workflow:');
+            console.log('     1. Review next step above');
+            console.log('     2. Work on the task');
+            console.log('     3. Commit & push');
+            console.log('     4. Run `versioning reentry update` again\n');
+        }))
+            .addCommand(new commander_1.Command('show')
+            .description('Show current re-entry status summary')
+            .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+            .option('-p, --project <name>', 'project scope')
+            .option('--json', 'Output as JSON', false)
+            .action(async (options) => {
+            const { status } = await ensureReentryInitialized(options.config, false, options.project);
+            if (options.json) {
+                console.log(JSON.stringify(status, null, 2));
+                return;
+            }
+            const milestoneText = status.milestone
+                ? `${status.milestone.title} (${status.milestone.id})`
+                : '—';
+            const nextStep = status.nextSteps?.[0]?.description ?? '—';
+            const gitCommit = status.context?.gitInfo?.commit || '—';
+            const gitBranch = status.context?.gitInfo?.branch || '—';
+            console.log('\n┌───────────────────────────────────────────┐');
+            console.log('│         📋 Re-entry Status Summary         │');
+            console.log('├───────────────────────────────────────────┤');
+            console.log(`│  Version:     ${status.version.padEnd(28)}│`);
+            console.log(`│  Phase:       ${status.currentPhase.padEnd(28)}│`);
+            console.log(`│  Branch:      ${gitBranch.padEnd(28)}│`);
+            console.log(`│  Commit:      ${gitCommit.padEnd(28)}│`);
+            console.log(`│  Milestone:   ${milestoneText.padEnd(28).substring(0, 28)}│`);
+            console.log(`│  Next step:   ${nextStep.padEnd(28).substring(0, 28)}│`);
+            console.log(`│  Updated:     ${status.lastUpdated.substring(0, 19).padEnd(28)}│`);
+            console.log(`│  Roadmap:     ${status.roadmapFile.padEnd(28).substring(0, 28)}│`);
+            console.log('└───────────────────────────────────────────┘\n');
         }))
             .addCommand(new commander_1.Command('sync')
             .description('Ensure generated status files exist and are up to date (idempotent)')
             .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+            .option('-p, --project <name>', 'project scope (separate ROADMAP/REENTRY/status per project)')
             .option('--migrate', 'rewrite v1.0 schema to v1.1 (no semantic changes)', false)
             .action(async (options) => {
-            const cfg = await loadRootConfigFile(options.config);
-            const reentryCfg = config_manager_1.ConfigManager.loadConfig(cfg);
-            const status = await ensureReentryInitialized(options.config, Boolean(options.migrate));
+            const { cfg, status } = await ensureReentryInitialized(options.config, Boolean(options.migrate), options.project);
+            const reentryCfg = config_manager_1.ConfigManager.loadConfig(cfg, options.project);
             // Ensure ROADMAP exists (light touch: only managed block is updated).
             const roadmapPath = status.roadmapFile || roadmap_renderer_1.RoadmapRenderer.defaultRoadmapPath();
             const existing = await fileManager.readFileIfExists(roadmapPath);
@@ -290,20 +528,28 @@ const extension = {
             }
             console.log('✅ Re-entry sync complete');
         }));
+        // ─────────────────────────────────────────────
+        //  ROADMAP COMMANDS (expanded with project identification)
+        // ─────────────────────────────────────────────
         program
             .command('roadmap')
             .description('Manage roadmap/backlog (slow layer)')
             .addCommand(new commander_1.Command('init')
             .description(`Create ${constants_1.REENTRY_STATUS_DIRNAME}/${constants_1.ROADMAP_MD_FILENAME} if missing and ensure managed header block`)
             .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+            .option('-p, --project <name>', 'project scope (separate ROADMAP/REENTRY/status per project)')
             .option('-t, --title <title>', 'project title for ROADMAP.md template', 'Untitled')
             .action(async (options) => {
-            const cfg = await loadRootConfigFile(options.config);
-            const status = await ensureReentryInitialized(options.config, false);
+            const projectKey = await validateProjectOption(options.config, options.project);
+            const { cfg, status } = await ensureReentryInitialized(options.config, false, projectKey);
             const roadmapPath = status.roadmapFile || roadmap_renderer_1.RoadmapRenderer.defaultRoadmapPath();
+            // If a project is specified and title is left default, prefer a non-stale title.
+            const title = projectKey && String(options.title).trim() === 'Untitled'
+                ? String(options.project ?? projectKey)
+                : String(options.title);
             const existing = await fileManager.readFileIfExists(roadmapPath);
             if (!existing) {
-                await fileManager.writeFileIfChanged(roadmapPath, roadmap_renderer_1.RoadmapRenderer.renderTemplate({ projectTitle: options.title }, { milestone: status.milestone, roadmapFile: roadmapPath }));
+                await fileManager.writeFileIfChanged(roadmapPath, roadmap_renderer_1.RoadmapRenderer.renderTemplate({ projectTitle: title }, { milestone: status.milestone, roadmapFile: roadmapPath }));
                 console.log(`✅ Created ${roadmapPath}`);
                 return;
             }
@@ -317,12 +563,40 @@ const extension = {
             }
             // Keep REENTRY.md consistent with roadmap references.
             await fileManager.writeReentryMarkdown(cfg, status);
+        }))
+            .addCommand(new commander_1.Command('validate')
+            .description('Validate that project roadmaps correspond to existing workspaces (detect stale roadmaps)')
+            .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+            .action(async (options) => {
+            const { slugs } = await discoverWorkspaceProjects(String(options.config));
+            const projectsDir = path.join(path.dirname(String(options.config)), constants_1.REENTRY_STATUS_DIRNAME, 'projects');
+            if (!(await fs.pathExists(projectsDir))) {
+                console.log('✅ No project roadmaps found');
+                return;
+            }
+            const entries = await fs.readdir(projectsDir, { withFileTypes: true });
+            const stale = [];
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const key = entry.name;
+                if (!slugs.has(key)) {
+                    stale.push(key);
+                }
+            }
+            if (stale.length === 0) {
+                console.log('✅ All project roadmaps match a workspace');
+                return;
+            }
+            console.warn(`⚠️  Stale project roadmaps found (no matching workspace): ${stale.join(', ')}`);
+            process.exitCode = 1;
         }))
             .addCommand(new commander_1.Command('list')
             .description('List roadmap milestones parsed from ROADMAP.md')
             .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+            .option('-p, --project <name>', 'project scope (separate ROADMAP/REENTRY/status per project)')
             .action(async (options) => {
-            const status = await ensureReentryInitialized(options.config, false);
+            const { status } = await ensureReentryInitialized(options.config, false, options.project);
             const roadmapPath = status.roadmapFile || roadmap_renderer_1.RoadmapRenderer.defaultRoadmapPath();
             const content = await fileManager.readFileIfExists(roadmapPath);
             if (!content) {
@@ -346,9 +620,9 @@ const extension = {
             .requiredOption('--id <id>', 'Milestone id (must match a [id] in ROADMAP.md)')
             .requiredOption('--title <title>', 'Milestone title')
             .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+            .option('-p, --project <name>', 'project scope (separate ROADMAP/REENTRY/status per project)')
             .action(async (options) => {
-            const cfg = await loadRootConfigFile(options.config);
-            const status = await ensureReentryInitialized(options.config, false);
+            const { cfg, status } = await ensureReentryInitialized(options.config, false, options.project);
             const next = {
                 ...status,
                 schemaVersion: '1.1',
@@ -365,8 +639,9 @@ const extension = {
             .requiredOption('--item <item>', 'Item text')
             .option('--id <id>', 'Optional explicit id (e.g., now-02)')
             .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+            .option('-p, --project <name>', 'project scope (separate ROADMAP/REENTRY/status per project)')
             .action(async (options) => {
-            const status = await ensureReentryInitialized(options.config, false);
+            const { status } = await ensureReentryInitialized(options.config, false, options.project);
             const roadmapPath = status.roadmapFile || roadmap_renderer_1.RoadmapRenderer.defaultRoadmapPath();
             const content = await fileManager.readFileIfExists(roadmapPath);
             if (!content) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edcalderon/versioning",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "A comprehensive versioning and changelog management tool for monorepos",
   "main": "dist/index.js",
   "bin": {
@@ -78,4 +78,4 @@
     "url": "git+https://github.com/edcalderon/my-second-brain.git",
     "directory": "packages/versioning"
   }
-}
+}