@mrpatronz/nexusflow 2.11.0 → 2.12.0

package/dist/server.js

@@ -1,3 +1,4 @@
+import { registerWorkGuidanceRoutes } from './http/work-guidance-routes.js';
 /**
  * @module server
  * Hono local web server for the NexusFlow GUI.
@@ -27,10 +28,11 @@ import { loadProjects, createProject, updateProject, removeProject, slugifyProje
 import { getSessionCwd, isInPlace, resolveFeatureRepoPath } from './utils/feature.js';
 import { listBranches } from './utils/git.js';
 import { checkRepoFreshness, checkReposFreshness, fastForwardRepos, } from './utils/repo-freshness.js';
-import { createWorkspace, listWorkspaces, loadFeatureConfig, loadWorkspaceManifest, deleteWorkspace, addRepoToWorkspace, isolateWorkspaceRepo } from './core/workspace.js';
+import { createWorkspace, listWorkspaces, loadFeatureConfig, saveFeatureConfig, loadWorkspaceManifest, deleteWorkspace, addRepoToWorkspace, isolateWorkspaceRepo } from './core/workspace.js';
 import { loadWorkspaceState } from './core/workspace-state.js';
 import { analyzeAllRepos } from './analyzers/index.js';
 import { generateContextFiles } from './generators/index.js';
+import { getAvailableOrganizations, getAvailableDomainPacks, getOrganization, getDomainPack, matchDomainPacks, resolveActiveDomainRules, saveDomainPack, deleteDomainPack, saveOrganization, deleteOrganization, } from './core/domain-packs.js';
 import { detectAIAssistants } from './utils/detect-ai.js';
 import { detectEditors } from './utils/detect-editors.js';
 import { buildWorkspaceLaunchPrompt, detectWorkspaceLaunchTargets, launchTargetIdForEditorCommand, launchWorkspaceTarget, } from './utils/workspace-launch.js';
@@ -1013,6 +1015,8 @@ async function runCreationJob(jobId, body, config) {
         const feature = {
             id: workspaceId,
             mode: inPlace ? 'in-place' : 'worktree',
+            flowType: body.flowType,
+            workType: body.workType,
             projectId: body.projectId,
             // In-place features never create a branch; keeping branchName populated
             // (= id) avoids breaking every consumer of the non-optional field.
@@ -1028,6 +1032,10 @@ async function runCreationJob(jobId, body, config) {
             createdAt: new Date().toISOString(),
             resumption: body.resumption,
             teamworkInstructions: body.teamworkInstructions,
+            organizationId: body.organizationId,
+            domainPacks: Array.isArray(body.domainPacks) && body.domainPacks.length > 0
+                ? body.domainPacks
+                : matchDomainPacks(body.description, (body.repos || []).map((r) => r.name)).map((p) => p.id),
         };
         if (job) {
             job.feature = feature;
@@ -1081,6 +1089,12 @@ async function runCreationJob(jobId, body, config) {
 app.post('/api/workspace', async (c) => {
     try {
         const body = await c.req.json();
+        if (body.workType !== undefined && !['bug', 'feature', 'performance', 'refactor', 'rewrite'].includes(body.workType)) {
+            return c.json({ error: 'Choose a valid work type.' }, 400);
+        }
+        if (body.flowType !== undefined && !['quick', 'feature', 'epic'].includes(body.flowType)) {
+            return c.json({ error: 'flowType must be quick, feature, or epic.' }, 400);
+        }
         const inPlace = body.mode === 'in-place';
         if (inPlace && !body.name?.trim()) {
             return c.json({ error: 'In-place workspaces need a "name"' }, 400);
@@ -2115,12 +2129,76 @@ app.get('/api/workspace/:id/plan', async (c) => {
                 throw err;
             }
         }
+        const state = await loadWorkspaceState(workspacePath);
+        if (state.lifecycle) {
+            const { renderLifecyclePlan } = await import('./core/lifecycle.js');
+            const milestones = renderLifecyclePlan(state.lifecycle);
+            const marker = /<!-- CONTEXTSPACE:MILESTONES:START -->[\s\S]*?<!-- CONTEXTSPACE:MILESTONES:END -->/;
+            content = marker.test(content) ? content.replace(marker, () => milestones) : `${milestones}\n\n${content}`;
+        }
         return c.json({ content });
     }
     catch (error) {
         return errorResponse(c, error);
     }
 });
+registerWorkGuidanceRoutes(app, async (id) => {
+    const config = await loadConfig();
+    return resolveExactWorkspaceById(config.workspacesDir, id);
+});
+// 13c-1. Get active workspace lifecycle and sister branch fleet
+app.get('/api/workspace/:id/lifecycle', async (c) => {
+    try {
+        const id = c.req.param('id');
+        const config = await loadConfig();
+        const workspacePath = resolveWorkspacePath(config.workspacesDir, id);
+        const { loadWorkspaceLifecycle, renderLifecyclePlan } = await import('./core/lifecycle.js');
+        const lifecycle = await loadWorkspaceLifecycle(workspacePath);
+        const report = (await loadWorkspaceState(workspacePath)).lastVerification ?? null;
+        return c.json({ lifecycle, report, plan: renderLifecyclePlan(lifecycle) });
+    }
+    catch (error) {
+        return errorResponse(c, error);
+    }
+});
+// 13c-2. Transition or advance a lifecycle step
+app.post('/api/workspace/:id/lifecycle/step', async (c) => {
+    try {
+        const id = c.req.param('id');
+        const config = await loadConfig();
+        const workspacePath = resolveWorkspacePath(config.workspacesDir, id);
+        const body = (await c.req.json().catch(() => ({})));
+        if (!body.stepId || !body.action) {
+            return c.json({ error: 'stepId and action (start|verify|complete) are required.' }, 400);
+        }
+        const { advanceLifecycleStep } = await import('./core/lifecycle.js');
+        const lifecycle = await advanceLifecycleStep(workspacePath, body.stepId, body.action);
+        return c.json({ lifecycle });
+    }
+    catch (error) {
+        return errorResponse(c, error);
+    }
+});
+// 13c-3. Run mechanical verification gate for workspace
+app.post('/api/workspace/:id/verify', async (c) => {
+    try {
+        const id = c.req.param('id');
+        const config = await loadConfig();
+        const workspacePath = resolveWorkspacePath(config.workspacesDir, id);
+        const body = (await c.req.json().catch(() => ({})));
+        const { verifyWorkspace } = await import('./core/verify.js');
+        const report = await verifyWorkspace(workspacePath, {
+            repoName: body.repoName,
+            filter: body.filter,
+            command: body.command,
+            allowDirty: body.allowDirty,
+        });
+        return c.json({ report });
+    }
+    catch (error) {
+        return errorResponse(c, error);
+    }
+});
 // 13c-2. Check workspace migration status (legacy NexusFlow files detected)
 app.get('/api/workspace/:id/migration-status', async (c) => {
     try {
@@ -2696,7 +2774,13 @@ app.delete('/api/skills/categories/:id', async (c) => {
 // materializations are deliberately never treated as catalog sources.
 app.get('/api/skills', async (c) => {
     try {
-        const skills = await getAllSkills();
+        const config = await loadConfig();
+        const wsParam = c.req.query('workspace');
+        let wsPath;
+        if (wsParam && wsParam !== 'global') {
+            wsPath = (await resolveExactWorkspaceById(config.workspacesDir, wsParam)) || undefined;
+        }
+        const skills = await getAllSkills(wsPath);
         return c.json({ skills });
     }
     catch (error) {
@@ -2710,7 +2794,23 @@ app.post('/api/skills', async (c) => {
         if (!body.name || !body.content) {
             return c.json({ error: 'Skill name and content are required.' }, 400);
         }
-        const skill = await saveSkill(body);
+        const config = await loadConfig();
+        const wsParam = body.workspaceId || body.workspace || c.req.query('workspace');
+        let wsPath;
+        if (wsParam && wsParam !== 'global') {
+            wsPath = (await resolveExactWorkspaceById(config.workspacesDir, wsParam)) || undefined;
+            if (!wsPath) {
+                return c.json({ error: `Workspace "${wsParam}" not found.` }, 404);
+            }
+        }
+        if (body.scope === 'workspace' && !wsPath) {
+            return c.json({ error: 'A valid workspace is required when saving a workspace-scoped skill.' }, 400);
+        }
+        const isWorkspaceScope = body.scope === 'workspace' || (Boolean(wsPath) && body.scope !== 'global');
+        const options = isWorkspaceScope && wsPath
+            ? { scope: 'workspace', workspacePath: wsPath }
+            : { scope: 'global' };
+        const skill = await saveSkill(body, options);
         return c.json({ success: true, skill });
     }
     catch (error) {
@@ -2723,6 +2823,18 @@ app.delete('/api/skills/:id', async (c) => {
     try {
         const id = decodeURIComponent(c.req.param('id'));
         const config = await loadConfig();
+        const wsParam = c.req.query('workspace');
+        let wsPath;
+        if (wsParam && wsParam !== 'global') {
+            wsPath = (await resolveExactWorkspaceById(config.workspacesDir, wsParam)) || undefined;
+            if (!wsPath) {
+                return c.json({ error: `Workspace "${wsParam}" not found.` }, 404);
+            }
+        }
+        if (wsPath) {
+            await deleteSkill(id, { scope: 'workspace', workspacePath: wsPath });
+            return c.json({ success: true });
+        }
         const assignments = await withResourceAdministrationLock(async () => {
             const currentAssignments = await findResourceAssignments(config.workspacesDir, id, 'skill');
             if (!currentAssignments.length)
@@ -2738,7 +2850,8 @@ app.delete('/api/skills/:id', async (c) => {
         return c.json({ success: true });
     }
     catch (error) {
-        return errorResponse(c, error);
+        const message = error instanceof Error ? error.message : String(error);
+        return c.json({ error: message }, 400);
     }
 });
 // Codex-native custom-agent catalog. Other harness agent formats are not
@@ -2841,6 +2954,216 @@ app.post('/api/skills/workspace/:id/assign', async (c) => {
         return errorResponse(c, error);
     }
 });
+// ─── Enterprise & Modular Domain Packs ─────────────────────────────────────
+// List available enterprise organizations
+app.get('/api/enterprise/organizations', (c) => {
+    return c.json({ organizations: getAvailableOrganizations() });
+});
+// Register custom organization conventions
+app.post('/api/enterprise/organizations', async (c) => {
+    try {
+        const body = await c.req.json();
+        if (!body.id || !body.name || !Array.isArray(body.rules)) {
+            return c.json({ error: 'id, name, and rules array are required for an organization.' }, 400);
+        }
+        await saveOrganization(body);
+        return c.json({ success: true, organization: getOrganization(body.id) });
+    }
+    catch (error) {
+        return errorResponse(c, error);
+    }
+});
+// Unregister custom organization
+app.delete('/api/enterprise/organizations/:id', async (c) => {
+    const id = decodeURIComponent(c.req.param('id'));
+    const deleted = await deleteOrganization(id);
+    return c.json({ success: deleted });
+});
+// List available domain packs
+app.get('/api/enterprise/domain-packs', (c) => {
+    return c.json({ domainPacks: getAvailableDomainPacks() });
+});
+// Get a single domain pack by ID
+app.get('/api/enterprise/domain-packs/:id', (c) => {
+    const id = decodeURIComponent(c.req.param('id')).toLowerCase().trim();
+    const pack = getDomainPack(id);
+    if (!pack) {
+        return c.json({ error: `Domain pack "${id}" not found.` }, 404);
+    }
+    return c.json({ domainPack: pack });
+});
+// Register custom domain pack
+app.post('/api/enterprise/domain-packs', async (c) => {
+    try {
+        const body = await c.req.json();
+        if (!body.id || !body.name) {
+            return c.json({ error: 'id and name are required for a domain pack.' }, 400);
+        }
+        const normalizedId = body.id.toLowerCase().trim();
+        const tags = Array.isArray(body.tags) && body.tags.length > 0
+            ? body.tags
+            : [normalizedId, ...body.name.toLowerCase().split(/\s+/).filter(Boolean)];
+        const packToRegister = {
+            ...body,
+            id: normalizedId,
+            tags,
+            isTemplate: false,
+        };
+        await saveDomainPack(packToRegister);
+        return c.json({ success: true, domainPack: getDomainPack(normalizedId) });
+    }
+    catch (error) {
+        return errorResponse(c, error);
+    }
+});
+// Update or customize a domain pack
+app.put('/api/enterprise/domain-packs/:id', async (c) => {
+    try {
+        const id = decodeURIComponent(c.req.param('id')).toLowerCase().trim();
+        const existing = getDomainPack(id);
+        if (!existing) {
+            return c.json({ error: `Domain pack "${id}" not found.` }, 404);
+        }
+        const body = await c.req.json();
+        const tags = Array.isArray(body.tags)
+            ? body.tags
+            : (existing.tags ?? [id, ...(body.name || existing.name || id).toLowerCase().split(/\s+/).filter(Boolean)]);
+        const updatedPack = {
+            id,
+            name: body.name ?? existing.name ?? id,
+            description: body.description ?? existing.description ?? '',
+            categoryType: body.categoryType ?? existing.categoryType ?? 'vertical',
+            parent: body.parent !== undefined ? (body.parent ? body.parent.trim() : undefined) : existing.parent,
+            organization: body.organization ?? existing.organization,
+            tags,
+            skills: Array.isArray(body.skills) ? body.skills : existing.skills,
+            contextFiles: Array.isArray(body.contextFiles) ? body.contextFiles : existing.contextFiles,
+            verifyCommand: body.verifyCommand !== undefined ? (body.verifyCommand ? body.verifyCommand.trim() : undefined) : existing.verifyCommand,
+            rules: Array.isArray(body.rules) ? body.rules : existing.rules,
+            defaultRepos: Array.isArray(body.defaultRepos) ? body.defaultRepos : existing.defaultRepos,
+            microservices: Array.isArray(body.microservices) ? body.microservices : existing.microservices,
+            isTemplate: false,
+        };
+        await saveDomainPack(updatedPack);
+        return c.json({ success: true, domainPack: getDomainPack(id) });
+    }
+    catch (error) {
+        return errorResponse(c, error);
+    }
+});
+// Unregister custom domain pack
+app.delete('/api/enterprise/domain-packs/:id', async (c) => {
+    const id = decodeURIComponent(c.req.param('id')).toLowerCase().trim();
+    const deleted = await deleteDomainPack(id);
+    return c.json({ success: deleted });
+});
+// Auto-match domain packs from specification or description
+app.post('/api/enterprise/match-domains', async (c) => {
+    try {
+        const body = await c.req.json();
+        const text = body.description || '';
+        const repos = Array.isArray(body.repos) ? body.repos : [];
+        const matched = matchDomainPacks(text, repos);
+        return c.json({ matched });
+    }
+    catch (error) {
+        return errorResponse(c, error);
+    }
+});
+// Get domain packs & organization conventions for a workspace
+app.get('/api/workspace/:id/domain-packs', async (c) => {
+    try {
+        const id = decodeURIComponent(c.req.param('id'));
+        const config = await loadConfig();
+        const wsPath = await resolveExactWorkspaceById(config.workspacesDir, id);
+        if (!wsPath)
+            return c.json({ error: 'Workspace not found.' }, 404);
+        const feature = await loadFeatureConfig(wsPath);
+        if (!feature)
+            return c.json({ error: 'Failed to load workspace feature.' }, 404);
+        const resolved = resolveActiveDomainRules(feature.organizationId, feature.domainPacks ?? []);
+        return c.json({
+            organizationId: feature.organizationId,
+            assignedDomainPackIds: feature.domainPacks ?? [],
+            ...resolved,
+        });
+    }
+    catch (error) {
+        return errorResponse(c, error);
+    }
+});
+// Assign or update domain packs & organization for a workspace
+app.post('/api/workspace/:id/domain-packs', async (c) => {
+    try {
+        const id = decodeURIComponent(c.req.param('id'));
+        const body = await c.req.json();
+        const config = await loadConfig();
+        const wsPath = await resolveExactWorkspaceById(config.workspacesDir, id);
+        if (!wsPath)
+            return c.json({ error: 'Workspace not found.' }, 404);
+        const feature = await loadFeatureConfig(wsPath);
+        if (!feature)
+            return c.json({ error: 'Failed to load workspace feature.' }, 404);
+        if (body.organizationId !== undefined) {
+            feature.organizationId = body.organizationId;
+        }
+        if (Array.isArray(body.domainPacks)) {
+            feature.domainPacks = body.domainPacks;
+        }
+        await saveFeatureConfig(wsPath, feature);
+        // Refresh workspace context so AGENTS.md immediately reflects active domain rules
+        await refreshWorkspace(wsPath, { force: true }).catch(() => { });
+        const resolved = resolveActiveDomainRules(feature.organizationId, feature.domainPacks ?? []);
+        return c.json({
+            success: true,
+            feature,
+            ...resolved,
+        });
+    }
+    catch (error) {
+        return errorResponse(c, error);
+    }
+});
+// Update workspace specification / PO requirements & adaptively match domain packs
+app.post('/api/workspace/:id/update-spec', async (c) => {
+    try {
+        const id = decodeURIComponent(c.req.param('id'));
+        const body = await c.req.json();
+        if (!body.description || typeof body.description !== 'string') {
+            return c.json({ error: 'Description is required.' }, 400);
+        }
+        const config = await loadConfig();
+        const wsPath = await resolveExactWorkspaceById(config.workspacesDir, id);
+        if (!wsPath)
+            return c.json({ error: 'Workspace not found.' }, 404);
+        const feature = await loadFeatureConfig(wsPath);
+        if (!feature)
+            return c.json({ error: 'Failed to load workspace feature.' }, 404);
+        feature.description = body.description.trim();
+        const newlyMatched = [];
+        if (body.autoMatchDomains !== false) {
+            const matchedPacks = matchDomainPacks(feature.description);
+            const currentPacks = new Set(feature.domainPacks ?? []);
+            for (const pack of matchedPacks) {
+                if (!currentPacks.has(pack.id)) {
+                    currentPacks.add(pack.id);
+                    newlyMatched.push(pack.id);
+                }
+            }
+            feature.domainPacks = Array.from(currentPacks);
+        }
+        await saveFeatureConfig(wsPath, feature);
+        await refreshWorkspace(wsPath, { force: true }).catch(() => { });
+        return c.json({
+            success: true,
+            feature,
+            newlyMatched,
+        });
+    }
+    catch (error) {
+        return errorResponse(c, error);
+    }
+});
 // ─── Workrooms: opt-in LAN/VPN collaboration ─────────────────────────────
 const WORKROOM_HUMAN_SESSION_COOKIES = [
     'contextspace_workroom_human',