@ctrl-spc/cli 1.3.1 → 1.3.3

package/dist/commands/init.js

@@ -1,8 +1,10 @@
-import { createHash } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { getMachineIdentity } from '../config.js';
-import { normalizeRemoteUrl } from '../git.js';
+import { ensureLocalRepositoryIdentity, isLocalRepositoryKey, normalizeRemoteUrl, readLocalRepositoryIdentity, readRootCommitSha } from '../git.js';
 import { getClient } from '../supabase.js';
+import { detectRoleFingerprint } from '../role-detection.js';
+import { isValidRoleSlug, ROLE_SUGGESTIONS } from '../roles.js';
 import { ask, select } from '../prompt.js';
 import { buildTopologyTargets, componentTargetId, discoverRepositoryTopology, planExplicitGrouping, readGroupingManifest, repositoryTargetId, } from '../topology.js';
 import { upsertProjectLink } from './link.js';
@@ -30,13 +32,26 @@ export function parseInitArgs(argv) {
             flags.yes = true;
             continue;
         }
-        if (flag !== '--org' && flag !== '--name' && flag !== '--repo' && flag !== '--group' && flag !== '--manifest') {
+        if (flag === '--report-promotion-conflicts') {
+            flags.promotionConflictMode = 'report';
+            continue;
+        }
+        if (flag === '--skip-local-promotion') {
+            flags.skipLocalPromotion = true;
+            continue;
+        }
+        if (flag !== '--project' && flag !== '--org' && flag !== '--name' && flag !== '--repo' && flag !== '--group' && flag !== '--manifest' && flag !== '--role' && flag !== '--detected-role' && flag !== '--clear-role' && flag !== '--target') {
             throw new Error(`Unknown argument: ${flag}`);
         }
         const value = argv[i + 1];
         if (!value || value.startsWith('--'))
             throw new Error(`${flag} requires a value`);
-        if (flag === '--org')
+        if (flag === '--project') {
+            if (flags.project)
+                throw new Error('--project may only be provided once');
+            flags.project = value;
+        }
+        else if (flag === '--org')
             flags.org = value;
         else if (flag === '--name')
             flags.name = value;
@@ -47,6 +62,34 @@ export function parseInitArgs(argv) {
             repos.push(value);
             flags.repos = repos;
         }
+        else if (flag === '--clear-role' || flag === '--target') {
+            const values = flag === '--clear-role' ? flags.clearedRoleTargetIds ?? [] : flags.targetIds ?? [];
+            if (values.includes(value))
+                throw new Error(`${flag} may only be provided once for target "${value}"`);
+            values.push(value);
+            if (flag === '--clear-role')
+                flags.clearedRoleTargetIds = values;
+            else
+                flags.targetIds = values;
+        }
+        else if (flag === '--role' || flag === '--detected-role') {
+            const equals = value.indexOf('=');
+            if (equals < 1 || equals === value.length - 1)
+                throw new Error('--role requires <targetId>=<slug>[:label]');
+            const targetId = value.slice(0, equals);
+            const [slug, ...labelParts] = value.slice(equals + 1).split(':');
+            if (!isValidRoleSlug(slug))
+                throw new Error(`Invalid role slug: ${slug}`);
+            const roles = flags.roles ?? {};
+            if (roles[targetId])
+                throw new Error(`--role may only be provided once for target "${targetId}"`);
+            roles[targetId] = {
+                slug: slug,
+                ...(labelParts.length ? { label: labelParts.join(':') } : {}),
+                source: flag === '--detected-role' ? 'detected' : 'user',
+            };
+            flags.roles = roles;
+        }
         else {
             setGrouping(flags, 'custom');
             flags.groupManifest = value;
@@ -56,6 +99,15 @@ export function parseInitArgs(argv) {
     if (flags.name && (flags.grouping === 'split' || flags.grouping === 'custom')) {
         throw new Error('--name can only be used for a single project; name split/custom groups in their grouping choices.');
     }
+    if (flags.project && (flags.org || flags.name)) {
+        throw new Error('--project uses the existing project name and organization; do not combine it with --org or --name.');
+    }
+    if (flags.project && (flags.grouping === 'split' || flags.grouping === 'custom')) {
+        throw new Error('--project attaches one combined topology; --split and --manifest are not supported.');
+    }
+    if (flags.clearedRoleTargetIds?.some(targetId => flags.roles?.[targetId])) {
+        throw new Error('A target cannot use --role and --clear-role together.');
+    }
     return flags;
 }
 function isWithin(parent, child) {
@@ -91,7 +143,7 @@ export function topologyKeyForScopes(scopes) {
     const digest = createHash('sha256').update(JSON.stringify(members)).digest('hex');
     return `topology:v1:${digest}`;
 }
-function mergeDiscoveries(discoveries) {
+export function mergeDiscoveries(discoveries) {
     const selectedPaths = discoveries.map((item) => item.selectedPath);
     const candidates = discoveries.flatMap((item) => item.repositories);
     const byIdentity = new Map();
@@ -123,36 +175,34 @@ function mergeDiscoveries(discoveries) {
         repositories,
     };
 }
-function defaultTargetIds(discovery, mode) {
+function defaultTargetIds(discovery, mode, repositoryKeys) {
     if (mode === 'combine') {
-        return discovery.repositories.flatMap((repository) => repository.origin.status === 'normalized'
-            ? [repositoryTargetId(repository.origin.url)]
-            : []);
+        return discovery.repositories.map((repository) => repositoryTargetId(repositoryKeys.get(repository.rootPath)));
     }
     return discovery.repositories.flatMap((repository) => {
-        if (repository.origin.status !== 'normalized')
-            return [];
-        const remote = repository.origin.url;
+        const remote = repositoryKeys.get(repository.rootPath);
         return repository.componentCandidates.length > 0
             ? repository.componentCandidates.map((component) => componentTargetId(remote, component.relativePath))
             : [repositoryTargetId(remote)];
     });
 }
-function printDiscovery(discovery) {
+function printDiscovery(discovery, repositoryKeys) {
     console.log(`Discovered ${discovery.repositories.length} ${discovery.repositories.length === 1 ? 'repository' : 'repositories'}:`);
     for (const repository of discovery.repositories) {
-        const remote = repository.origin.status === 'normalized' ? repository.origin.url : 'missing origin';
-        const repositoryId = repository.origin.status === 'normalized' ? repositoryTargetId(repository.origin.url) : 'unavailable';
+        const remote = repository.origin.status === 'normalized' ? repository.origin.url : 'no Git remote';
+        const repositoryKey = repositoryKeys.get(repository.rootPath);
+        const repositoryId = isLocalRepositoryKey(repositoryKey) ? 'local repository' : repositoryTargetId(repositoryKey);
         console.log(`  - ${repository.rootPath} (${remote})`);
         console.log(`    target: ${repositoryId}`);
-        if (repository.origin.status === 'normalized') {
-            for (const component of repository.componentCandidates) {
-                console.log(`    component: ${component.relativePath} (${componentTargetId(repository.origin.url, component.relativePath)})`);
-            }
+        for (const component of repository.componentCandidates) {
+            const target = isLocalRepositoryKey(repositoryKey)
+                ? component.relativePath
+                : componentTargetId(repositoryKey, component.relativePath);
+            console.log(`    component: ${component.relativePath} (${target})`);
         }
     }
 }
-async function chooseGrouping(discovery, flags) {
+async function chooseGrouping(discovery, flags, repositoryKeys) {
     const hasMultipleRepositories = discovery.repositories.length > 1;
     const hasComponents = discovery.repositories.some((repository) => repository.componentCandidates.length > 0);
     const choiceRequired = hasMultipleRepositories || hasComponents;
@@ -179,7 +229,7 @@ async function chooseGrouping(discovery, flags) {
             throw new Error('Custom grouping requires --manifest <file>.');
         return readGroupingManifest(manifestPath);
     }
-    return { mode: grouping, targetIds: defaultTargetIds(discovery, grouping) };
+    return { mode: grouping, targetIds: defaultTargetIds(discovery, grouping, repositoryKeys) };
 }
 function projectNameForGroup(group, targets, flags, workspaceRoot) {
     if (group.name)
@@ -190,9 +240,17 @@ function projectNameForGroup(group, targets, flags, workspaceRoot) {
         return targets.get(group.targetIds[0]).label;
     return basename(workspaceRoot);
 }
-function planProjects(discovery, targets, grouping, flags) {
+export function planProjects(discovery, targets, grouping, flags, repositoryKeys) {
     const targetsById = new Map(targets.map((target) => [target.id, target]));
     const repositoriesByRoot = new Map(discovery.repositories.map((repository) => [repository.rootPath, repository]));
+    for (const targetId of Object.keys(flags.roles ?? {})) {
+        if (!targetsById.has(targetId))
+            throw new Error(`--role references unknown target "${targetId}"`);
+    }
+    for (const targetId of flags.clearedRoleTargetIds ?? []) {
+        if (!targetsById.has(targetId))
+            throw new Error(`--clear-role references unknown target "${targetId}"`);
+    }
     return grouping.groups.map((group) => {
         const selectedTargets = group.targetIds.map((id) => targetsById.get(id));
         const projectRoot = selectedTargets.length === 1 && selectedTargets[0].componentPath
@@ -201,12 +259,11 @@ function planProjects(discovery, targets, grouping, flags) {
         const componentRepositoryRoots = [...new Set(selectedTargets.filter((target) => target.componentPath !== null).map((target) => target.repositoryRoot))];
         const sharedContextScopes = componentRepositoryRoots.map((repositoryRoot, position) => {
             const repository = repositoriesByRoot.get(repositoryRoot);
-            if (repository.origin.status !== 'normalized')
-                throw new Error(`Missing origin for ${repository.rootPath}`);
+            const repositoryKey = repositoryKeys.get(repository.rootPath);
             const repositoryTargets = selectedTargets.filter((target) => target.repositoryRoot === repositoryRoot);
             const required = repositoryTargets.some((target) => grouping.targetConfiguration[target.id]?.required !== false);
             return {
-                remote_key: repository.origin.url,
+                remote_key: repositoryKey,
                 repository_name: basename(repository.rootPath),
                 scope_path: '',
                 kind: 'shared_context',
@@ -215,17 +272,27 @@ function planProjects(discovery, targets, grouping, flags) {
                 required,
                 position,
                 local_path: repository.rootPath,
-                verified_remote_key: repository.origin.url,
+                verified_remote_key: repositoryKey,
+                root_commit_sha: readRootCommitSha(repository.rootPath),
             };
         });
         const componentOrRepositoryScopes = selectedTargets.map((target, index) => {
             const repository = repositoriesByRoot.get(target.repositoryRoot);
-            if (repository.origin.status !== 'normalized')
-                throw new Error(`Missing origin for ${repository.rootPath}`);
+            const repositoryKey = repositoryKeys.get(repository.rootPath);
             const scopePath = target.componentPath ?? '';
             const config = grouping.targetConfiguration[target.id] ?? {};
+            const explicitRole = flags.roles?.[target.id];
+            const explicitlyCleared = flags.clearedRoleTargetIds?.includes(target.id) === true;
+            const detectedRole = explicitRole || explicitlyCleared ? null : detectRoleFingerprint(join(target.repositoryRoot, scopePath));
+            const role = explicitRole
+                ? {
+                    slug: explicitRole.slug,
+                    label: explicitRole.label ?? ROLE_SUGGESTIONS.find(item => item.slug === explicitRole.slug)?.label,
+                    source: explicitRole.source,
+                }
+                : config.role ?? (detectedRole ? { ...detectedRole, source: 'detected' } : undefined);
             return {
-                remote_key: repository.origin.url,
+                remote_key: repositoryKey,
                 repository_name: basename(repository.rootPath),
                 scope_path: scopePath,
                 kind: scopePath ? 'component' : 'repository',
@@ -236,7 +303,17 @@ function planProjects(discovery, targets, grouping, flags) {
                 required: config.required ?? true,
                 position: sharedContextScopes.length + index,
                 local_path: repository.rootPath,
-                verified_remote_key: repository.origin.url,
+                verified_remote_key: repositoryKey,
+                root_commit_sha: readRootCommitSha(repository.rootPath),
+                ...(role ? {
+                    role_slug: role.slug,
+                    role_label: role.label ?? null,
+                    role_source: role.source,
+                } : explicitlyCleared ? {
+                    role_slug: null,
+                    role_label: null,
+                    role_source: 'user',
+                } : {}),
             };
         });
         const scopes = [...sharedContextScopes, ...componentOrRepositoryScopes];
@@ -260,47 +337,106 @@ async function confirmWritePlan(flags) {
         { label: 'No, make no changes', value: false },
     ]);
 }
-/** Discovers the selected workspace, confirms an explicit grouping whenever
- * more than one repository/component choice exists, then persists every
- * planned project. A plain single repository keeps the legacy atomic flow. */
-export async function init(argv = []) {
+async function promotePreviouslyLocalRepositories(client, orgId, discovery, conflictMode) {
+    for (const repository of discovery.repositories) {
+        if (repository.origin.status !== 'normalized')
+            continue;
+        const localIdentity = readLocalRepositoryIdentity(repository.rootPath);
+        if (!localIdentity)
+            continue;
+        const { data, error } = await client.rpc('promote_local_repository', {
+            p_org: orgId,
+            p_local_identity: localIdentity,
+            p_remote_key: repository.origin.url,
+            ...(conflictMode ? { p_on_conflict: conflictMode } : {}),
+        });
+        if (error)
+            throw new Error(`Could not connect the new Git remote: ${error.message}`);
+        if (data?.status === 'promoted') {
+            console.log(`Connected Git remote for ${basename(repository.rootPath)} — ${repository.origin.url}`);
+        }
+        if (data?.status === 'conflict') {
+            console.error(`CTRL_SPC_PROMOTION_CONFLICT=${JSON.stringify(data)}`);
+            throw new Error('This folder is already online through another project folder.');
+        }
+    }
+}
+async function loadEmptyAttachmentTarget(client, projectId) {
+    const { data, error } = await client
+        .from('projects')
+        .select('id,org_id,name,topology_revision,metadata_revision,archived_at')
+        .eq('id', projectId)
+        .maybeSingle();
+    if (error)
+        throw new Error(`Could not load project "${projectId}": ${error.message}`);
+    if (!data)
+        throw new Error(`No accessible project found for id "${projectId}".`);
+    const project = data;
+    if (project.archived_at) {
+        throw new Error(`Project "${project.name}" is archived. Restore it in the web app before attaching codebases.`);
+    }
+    return project;
+}
+export async function init(argv = [], deps = {}) {
     let flags;
     try {
         flags = parseInitArgs(argv);
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : String(err));
-        console.error('Usage: ctrl-spc init [--org <org-id>] [--name <project-name>] ' +
-            '[--repo <path> ...] [--combine | --split | --manifest <manifest.json>] [--yes]');
+        console.error('Usage: ctrl-spc init [--project <project-id>] [--org <org-id>] [--name <project-name>] ' +
+            '[--repo <path> ...] [--combine | --split | --manifest <manifest.json>] [--role <target>=<slug>[:label] ...] [--yes]');
         process.exitCode = 1;
         return;
     }
     const cwd = process.cwd();
     let discovery;
+    let repositoryKeys = new Map();
     let groupingSelection;
     let groupedProjects = [];
     try {
         const selectedPaths = (flags.repos?.length ? flags.repos : [cwd]).map((path) => resolve(cwd, path));
         discovery = mergeDiscoveries(selectedPaths.map((path) => discoverRepositoryTopology(path)));
         if (discovery.repositories.length === 0) {
-            throw new Error('No Git repositories were discovered. Add an origin remote or pass one or more --repo paths.');
-        }
-        const missingOrigins = discovery.repositories.filter((repository) => repository.origin.status === 'missing_origin');
-        if (missingOrigins.length > 0) {
-            throw new Error(`No git remote "origin" found for: ${missingOrigins.map((repository) => repository.rootPath).join(', ')}. ` +
-                'Add an origin remote before initializing.');
+            throw new Error('No Git repositories were discovered. Choose a folder containing a Git repository.');
         }
-        printDiscovery(discovery);
-        groupingSelection = await chooseGrouping(discovery, flags);
+        repositoryKeys = new Map(discovery.repositories.map((repository) => [
+            repository.rootPath,
+            repository.origin.status === 'normalized'
+                ? repository.origin.url
+                : ensureLocalRepositoryIdentity(repository.rootPath),
+        ]));
+        printDiscovery(discovery, repositoryKeys);
+        groupingSelection = flags.project
+            ? { mode: 'combine', targetIds: flags.targetIds ?? defaultTargetIds(discovery, 'combine', repositoryKeys) }
+            : await chooseGrouping(discovery, flags, repositoryKeys);
+        if (groupingSelection && flags.targetIds)
+            groupingSelection = { mode: 'combine', targetIds: flags.targetIds };
         if (groupingSelection) {
-            const targets = buildTopologyTargets(discovery);
+            const targets = buildTopologyTargets(discovery, (repository) => repositoryKeys.get(repository.rootPath));
             const grouping = planExplicitGrouping(targets, groupingSelection);
-            groupedProjects = planProjects(discovery, targets, grouping, flags);
+            if (deps.proposeRole) {
+                for (const target of targets.filter(candidate => grouping.targetIds.includes(candidate.id))) {
+                    if (flags.roles?.[target.id] || flags.clearedRoleTargetIds?.includes(target.id) || grouping.targetConfiguration[target.id]?.role)
+                        continue;
+                    const targetPath = join(target.repositoryRoot, target.componentPath ?? '');
+                    if (detectRoleFingerprint(targetPath))
+                        continue;
+                    const proposed = await deps.proposeRole(targetPath, ROLE_SUGGESTIONS.map(role => role.slug));
+                    if (!proposed || !ROLE_SUGGESTIONS.some(role => role.slug === proposed.slug))
+                        continue;
+                    grouping.targetConfiguration[target.id] = {
+                        ...(grouping.targetConfiguration[target.id] ?? {}),
+                        role: { slug: proposed.slug, label: proposed.label, source: 'agent' },
+                    };
+                }
+            }
+            groupedProjects = planProjects(discovery, targets, grouping, flags, repositoryKeys);
             console.log(`Grouping: ${grouping.mode === 'split' ? 'separate' : grouping.mode}`);
             for (const project of groupedProjects) {
                 console.log(`  - ${project.name}:`);
                 for (const scope of project.scopes) {
-                    console.log(`    ${scope.remote_key}${scope.scope_path ? `#${scope.scope_path}` : ''} — ` +
+                    console.log(`    ${isLocalRepositoryKey(scope.remote_key) ? 'No Git remote' : scope.remote_key}${scope.scope_path ? `#${scope.scope_path}` : ''} — ` +
                         `${scope.kind} — ${scope.required ? 'required' : 'optional'} — ${scope.purpose}`);
                 }
             }
@@ -319,7 +455,25 @@ export async function init(argv = []) {
         return;
     }
     const userId = userData.user.id;
-    let orgId = flags.org;
+    let attachmentTarget = null;
+    if (flags.project) {
+        try {
+            attachmentTarget = await loadEmptyAttachmentTarget(client, flags.project);
+        }
+        catch (err) {
+            console.error(err instanceof Error ? err.message : String(err));
+            process.exitCode = 1;
+            return;
+        }
+        if (groupedProjects.length !== 1) {
+            console.error('An existing project can only receive one combined repository topology.');
+            process.exitCode = 1;
+            return;
+        }
+        groupedProjects[0] = { ...groupedProjects[0], name: attachmentTarget.name };
+        console.log(`Attach to existing project: "${attachmentTarget.name}"`);
+    }
+    let orgId = attachmentTarget?.org_id ?? flags.org;
     let orgLabel = null;
     if (!orgId) {
         const org = await chooseOrg(client);
@@ -333,10 +487,11 @@ export async function init(argv = []) {
     }
     if (!groupingSelection) {
         const repository = discovery.repositories[0];
-        const key = repository.origin.status === 'normalized' ? repository.origin.url : '';
+        const key = repositoryKeys.get(repository.rootPath);
+        const identityLabel = isLocalRepositoryKey(key) ? 'No Git remote' : key;
         const defaultName = basename(repository.rootPath);
         const name = flags.name ?? (flags.org ? defaultName : await ask('Project name', defaultName));
-        console.log(`Review: ${name} — ${key} — required whole repository`);
+        console.log(`Review: ${name} — ${identityLabel} — required whole repository`);
         try {
             if (!await confirmWritePlan(flags)) {
                 console.log('Cancelled — no projects or repository links were changed.');
@@ -348,6 +503,15 @@ export async function init(argv = []) {
             process.exitCode = 1;
             return;
         }
+        try {
+            if (!flags.skipLocalPromotion)
+                await promotePreviouslyLocalRepositories(client, orgId, discovery, flags.promotionConflictMode);
+        }
+        catch (err) {
+            console.error(err instanceof Error ? err.message : String(err));
+            process.exitCode = 1;
+            return;
+        }
         const { data, error } = await client.rpc('init_project', {
             p_org: orgId,
             p_git_remote_url: key,
@@ -360,15 +524,19 @@ export async function init(argv = []) {
         }
         const result = data;
         switch (result.status) {
+            case 'archived_project':
+                console.error(`Project "${result.project_name}" is archived. Restore it in the web app before initializing this repository.`);
+                process.exitCode = 1;
+                return;
             case 'foreign_org':
-                console.error(`The repo ${key} is already registered to the organization "${result.org_name}", which you are not a member of. Ask an owner of "${result.org_name}" to invite you, then run \`ctrl-spc link\`.`);
+                console.error(`This repository is already registered to the organization "${result.org_name}", which you are not a member of. Ask an owner of "${result.org_name}" to invite you, then run \`ctrl-spc link\`.`);
                 process.exitCode = 1;
                 return;
             case 'exists':
-                console.log(`Project "${result.project_name}" is already registered (${result.org_name}, ${key}) — linking this machine.`);
+                console.log(`Project "${result.project_name}" is already registered (${result.org_name}) — linking this machine.`);
                 break;
             case 'created':
-                console.log(`Created project "${result.project_name}" in "${result.org_name ?? orgLabel}" — ${key}`);
+                console.log(`Created project "${result.project_name}" in "${result.org_name ?? orgLabel}" — ${identityLabel}`);
                 break;
         }
         try {
@@ -395,6 +563,56 @@ export async function init(argv = []) {
         return;
     }
     const machine = getMachineIdentity();
+    try {
+        if (!flags.skipLocalPromotion)
+            await promotePreviouslyLocalRepositories(client, orgId, discovery, flags.promotionConflictMode);
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exitCode = 1;
+        return;
+    }
+    if (attachmentTarget) {
+        const project = groupedProjects[0];
+        const requestId = randomUUID();
+        const { data, error } = await client.rpc('attach_project_topology', {
+            p_project: attachmentTarget.id,
+            p_expected_topology_revision: attachmentTarget.topology_revision,
+            p_expected_metadata_revision: attachmentTarget.metadata_revision,
+            p_request_id: requestId,
+            p_machine: machine.id,
+            p_machine_name: machine.name,
+            p_topology_key: project.topologyKey,
+            p_git_remote_url: project.legacyRemote,
+            p_workspace_root: project.workspaceRoot,
+            p_scopes: project.scopes,
+        });
+        if (error) {
+            const archived = /archiv/i.test(error.message);
+            console.error(archived
+                ? `Project "${attachmentTarget.name}" was archived before setup completed. Restore it in the web app and retry.`
+                : `Failed to attach codebases: ${error.message}`);
+            process.exitCode = 1;
+            return;
+        }
+        const result = data;
+        const valid = result
+            && (result.status === 'attached' || result.status === 'already_attached')
+            && result.project_id === attachmentTarget.id
+            && Number(result.scope_count) === project.scopes.length
+            && Number.isInteger(Number(result.topology_revision))
+            && Number(result.topology_revision) > 0;
+        if (!valid) {
+            console.error('Failed to attach codebases: the server response did not match the reviewed topology.');
+            process.exitCode = 1;
+            return;
+        }
+        await upsertProjectLink(client, userId, result.project_id, project.workspaceRoot);
+        console.log(`${result.status === 'already_attached' ? 'Confirmed' : 'Attached'} ${result.scope_count} ` +
+            `${result.scope_count === 1 ? 'scope' : 'scopes'} to "${result.project_name}" — topology revision ${result.topology_revision}`);
+        console.log(`Linked — local path ${project.workspaceRoot}`);
+        return;
+    }
     const { data, error } = await client.rpc('configure_project_topology_batch', {
         p_org: orgId,
         p_machine: machine.id,