@edcalderon/versioning 1.1.0 → 1.1.2

package/README.md

@@ -118,10 +118,21 @@ Features:
 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
@@ -129,11 +140,23 @@ Commands:
 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 (1–2 weeks)" --id "now-02" --item "Add observability"
+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:

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

@@ -3,10 +3,15 @@ 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): ReentryStatusConfig;
-    static mergeWithDefaults(partial: Partial<ReentryStatusConfig>): ReentryStatusConfig;
+    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

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 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) {
@@ -45,12 +46,78 @@ function defaultFilesConfig() {
         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) {
-        const partial = (rootConfig && typeof rootConfig === 'object' ? rootConfig.reentryStatus : undefined);
-        return ConfigManager.mergeWithDefaults(partial ?? {});
+    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) {
+    static mergeWithDefaults(partial, project) {
+        const defaults = defaultFilesConfigForProject(project);
         const merged = {
             enabled: partial.enabled ?? true,
             autoSync: partial.autoSync ?? true,
@@ -60,8 +127,8 @@ class ConfigManager {
                 postRelease: partial.hooks?.postRelease ?? false
             },
             files: {
-                jsonPath: partial.files?.jsonPath ?? defaultFilesConfig().jsonPath,
-                markdownPath: partial.files?.markdownPath ?? defaultFilesConfig().markdownPath
+                jsonPath: partial.files?.jsonPath ?? defaults.jsonPath,
+                markdownPath: partial.files?.markdownPath ?? defaults.markdownPath
             },
             github: partial.github,
             obsidian: partial.obsidian,

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

@@ -5,7 +5,7 @@ export interface RoadmapRenderOptions {
     projectTitle?: string;
 }
 export declare class RoadmapRenderer {
-    static defaultRoadmapPath(): string;
+    static defaultRoadmapPath(baseDir?: string): string;
     static renderManagedBlock(status?: Pick<ReentryStatus, 'milestone' | 'roadmapFile'>): string;
     static renderTemplate(options?: RoadmapRenderOptions, status?: Pick<ReentryStatus, 'milestone' | 'roadmapFile'>): string;
     /**

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

@@ -5,8 +5,8 @@ const constants_1 = require("./constants");
 exports.ROADMAP_MANAGED_START = '<!-- roadmap:managed:start -->';
 exports.ROADMAP_MANAGED_END = '<!-- roadmap:managed:end -->';
 class RoadmapRenderer {
-    static defaultRoadmapPath() {
-        return `${constants_1.REENTRY_STATUS_DIRNAME}/${constants_1.ROADMAP_MD_FILENAME}`;
+    static defaultRoadmapPath(baseDir = constants_1.REENTRY_STATUS_DIRNAME) {
+        return `${baseDir}/${constants_1.ROADMAP_MD_FILENAME}`;
     }
     static renderManagedBlock(status) {
         const milestoneText = status?.milestone

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");
@@ -50,7 +51,7 @@ const reentry_status_manager_1 = require("./reentry-status/reentry-status-manage
 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.1.2',
     hooks: {
         postVersion: async (type, version, options) => {
             try {
@@ -107,16 +108,103 @@ 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);
@@ -126,12 +214,17 @@ const extension = {
                         ...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 +237,7 @@ const extension = {
                     versioningInfo: {}
                 },
                 milestone: null,
-                roadmapFile: roadmap_renderer_1.RoadmapRenderer.defaultRoadmapPath(),
+                roadmapFile: defaultRoadmapPath,
                 currentPhase: 'planning',
                 milestones: [],
                 blockers: [],
@@ -162,7 +255,7 @@ const extension = {
                 }
             };
             await fileManager.writeStatusFiles(cfg, initial);
-            return initial;
+            return { cfg, status: initial };
         };
         program
             .command('reentry')
@@ -170,9 +263,10 @@ const extension = {
             .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 +274,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 = {
@@ -201,11 +295,11 @@ const extension = {
             .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);
@@ -296,14 +390,19 @@ const extension = {
             .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 +416,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 +473,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 +492,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.1.2",
   "description": "A comprehensive versioning and changelog management tool for monorepos",
   "main": "dist/index.js",
   "bin": {