git mv packages/business -> packages/organization (@mosaic/organization). The old package stays as one-line re-export shims of each moved module, with src/business.mjs re-exporting src/organization-config.mjs and src/cli.mjs forwarding to the moved executable. BusinessError is OrganizationConfigError (one constructor, name kept BusinessError); OrganizationError stays distinct. The bus adapter gains organization-context.mjs (busOrganization), with business.mjs (busBusiness) as the same function. Import consumers, manifests, the lockfile, scripts/mosaic, stack-copy.sh COPY_PATHS (both roots), seat sandbox RUNNER_FILES and the copy closure walker (organization-imports.mjs, both roots required) move to the new path. v1 serialization, v1 writers and the stage A fixtures are unchanged; the stage A contract tests stay where they were and pass as before.
149 lines
9.8 KiB
JavaScript
149 lines
9.8 KiB
JavaScript
// Lifecycle Task 2 (#797 / Gitea #1839, review I3): the host's own preparation and admission of a new-project
|
|
// plan, so a normal boot reaches a bootstrap selection without anything injected.
|
|
//
|
|
// Every input comes from something the host already holds: the validated organization document and its
|
|
// revision, the displayed source commit (prepareBootstrap reads it from the declared source checkout), the
|
|
// tracker configuration the host booted with, and the staff the organization names. A resource nothing can
|
|
// supply is a precise setup wait, never a placeholder: no tracker root, or a staff the organization does not
|
|
// name exactly, leaves the request waiting with a named code and creates nothing.
|
|
//
|
|
// Not verified here, because nothing the host holds can: that the tracker board the owner selected exists.
|
|
// That is checked when the first task is created, not before the owner confirms.
|
|
import { prepareBootstrap, prepareExistingPlan } from './request-bootstrap.mjs';
|
|
import { loadProject } from '../../organization/src/project.mjs';
|
|
import { digest, refuse } from './request-store.mjs';
|
|
|
|
const positive = n => Number.isSafeInteger(n) && n > 0;
|
|
const MODES = ['autonomous', 'guided'];
|
|
|
|
// The staff a bootstrapped project is built with, from the organization document alone: the request's PM, the
|
|
// technical arbiter, the launcher as chief, and the one launchable instance of each of the coder and reviewer
|
|
// roles. null unless every name is declared and the PM is not also the technical reviewer.
|
|
export function staffFor(document, pm) {
|
|
const roles = document?.roles, launch = document?.launch;
|
|
if (!roles || typeof roles !== 'object' || !launch || typeof launch.by !== 'string' || !Array.isArray(launch.instances)) return null;
|
|
const only = definition => {
|
|
const names = launch.instances.filter(i => roles[i]?.definition === definition);
|
|
return names.length === 1 ? names[0] : null;
|
|
};
|
|
const staff = { pm, technical_reviewer: document.arbiters?.technical, coder: only('coder'), reviewer: only('reviewer'), chief: launch.by };
|
|
const named = Object.values(staff).every(name => typeof name === 'string' && Object.hasOwn(roles, name));
|
|
return named && staff.pm !== staff.technical_reviewer ? staff : null;
|
|
}
|
|
|
|
// hostPreparation({ dataRoot, organization, trackers }) -> { preparePlans, admitPlan }
|
|
// `organization` is the organization writer, `trackers` the boot config's { business: { project, ... } }.
|
|
export function hostPreparation({ dataRoot, organization, trackers = null, journal, catalog, readSpec, admission, work = fn => fn() }) {
|
|
const read = business => { try { return organization.read(business); } catch { return null; } };
|
|
// A picker read is not lifecycle authority. Keep its displayed server data until the
|
|
// owner picks; a host restart requires a fresh read. The pick itself is journaled.
|
|
const displayed = new Map();
|
|
const owner = (state, now) => now?.document.human === state.owner;
|
|
const bindingFor = (business, project) => {
|
|
const origin = journal?.projectState(business, project);
|
|
const state = origin && journal.stateForRequest(origin.request);
|
|
return state?.selection?.bindings.find(b => b.digest === state.plan_digest)?.plan;
|
|
};
|
|
const inventory = state => {
|
|
const now = read(state.business);
|
|
if (!owner(state, now)) return [];
|
|
const found = resources(now.document, state.pm);
|
|
if (found.code) return [];
|
|
return Object.entries(now.document.projects).flatMap(([project, mapping]) => {
|
|
if (mapping.kind === 'library' || (admission && !admission({ business: state.business, project }).ready)) return [];
|
|
let config; try { config = loadProject(mapping.root); } catch { return []; }
|
|
if (config.id !== project) return [];
|
|
const previous = bindingFor(state.business, project);
|
|
const board = previous?.tracker.project ?? config.vars['tracker.project'];
|
|
if (!positive(board)) return [];
|
|
return [{ business: state.business, project, name: previous?.name ?? project,
|
|
tracker: { root: found.root, project: board }, mapping_revision: now.revision }];
|
|
});
|
|
};
|
|
// The tracker root board and the staff for one business, or the setup wait code that names what is missing.
|
|
const resources = (document, pm) => {
|
|
const root = trackers?.[document.id]?.project;
|
|
if (!positive(root)) return { code: 'request-tracker-unavailable' };
|
|
const staff = staffFor(document, pm);
|
|
return staff ? { root, staff } : { code: 'request-staff-unavailable' };
|
|
};
|
|
return {
|
|
listProjects(state, identity, { remember = true } = {}) {
|
|
const rows = inventory(state);
|
|
if (remember && identity?.human === state.owner) displayed.set(state.business + '/' + state.request, structuredClone(rows));
|
|
return rows;
|
|
},
|
|
pickExisting(state, project) {
|
|
const row = displayed.get(state.business + '/' + state.request)?.find(row => row.project === project);
|
|
if (!row) refuse('request-existing-project-changed');
|
|
const now = inventory(state).find(row => row.project === project);
|
|
if (!now || digest(now) !== digest(row)) refuse('request-existing-project-changed');
|
|
return row;
|
|
},
|
|
prepareExisting(state, args, from) {
|
|
const now = read(state.business);
|
|
if (!owner(state, now)) return { ready: false, code: 'request-organization-unavailable' };
|
|
if (state.attachment?.mapping_revision !== now.revision) return { ready: false, code: 'request-existing-project-changed' };
|
|
const row = inventory(state).find(row => row.project === args.project);
|
|
if (!row) return { ready: false, code: 'request-project-refused' };
|
|
const mode = journal.projectState(state.business, args.project)?.mode ?? 'guided';
|
|
return prepareExistingPlan({ business: now.document, request: state.request, project: args.project, name: row.name, mode,
|
|
dataRoot, organizationRevision: now.revision, tracker: row.tracker, staff: resources(now.document, state.pm).staff,
|
|
intent: { text: from.text, source_message: from.source_message } });
|
|
},
|
|
withExisting(state, fn) { return work(() => organization.holdAsync(state.business, fn)); },
|
|
async attachExisting(state, plan) {
|
|
const checked = this.admitPlan(plan);
|
|
if (!checked.ready) refuse(checked.code);
|
|
const mode = journal.projectState(state.business, state.project);
|
|
const spec = await readSpec({ business: state.business, project: state.project });
|
|
if (!spec.confirmed) refuse('stale-spec');
|
|
let snapshot = null, candidate = null;
|
|
try {
|
|
const current = await catalog.resolve({ business: state.business, project: state.project });
|
|
const source = current.origin === 'product' && journal.snapshotRequest(current.id);
|
|
// Exact prior intent is a provable fit. New intent needs PM discovery/revision,
|
|
// never guessed semantic equivalence or authority from a bare requirement id.
|
|
if (source && journal.intent(state.business, source)?.text === plan.intent.text) {
|
|
const original = journal.stateForRequest(source);
|
|
const submitted = journal.submission(state.business, source, current.approval.decision);
|
|
if (original?.project === state.project && submitted) { snapshot = current.id; candidate = submitted.candidate; }
|
|
}
|
|
} catch (e) {
|
|
if (!['requirement-snapshot-required','requirement-snapshot-revoked','prd-candidate-stale'].includes(e.code)) throw e;
|
|
}
|
|
const late = this.admitPlan(plan); if (!late.ready) refuse(late.code);
|
|
return { spec_commit: spec.commit, mode_revision: mode?.revision ?? 1, snapshot, candidate };
|
|
},
|
|
async preparePlans(state, args, from) {
|
|
const now = read(state.business);
|
|
if (!now) return { ready: false, code: 'request-organization-unavailable' };
|
|
const found = resources(now.document, state.pm);
|
|
if (found.code) return { ready: false, code: found.code };
|
|
return Promise.all(MODES.map(mode => prepareBootstrap({ business: now.document, request: state.request, sourceProject: args.source_project,
|
|
project: args.project, name: args.name, mode, dataRoot, organizationRevision: now.revision, tracker: { root: found.root, project: args.tracker_project },
|
|
staff: found.staff, intent: { text: from.text, source_message: from.source_message } })));
|
|
},
|
|
// May this plan be shown and confirmed: the organization is still at the revision it was prepared on, and the
|
|
// resources it names are the ones the host holds now.
|
|
admitPlan(plan) {
|
|
const now = read(plan.business);
|
|
if (!now) return { ready: false, code: 'request-organization-unavailable' };
|
|
if (now.revision !== plan.organization_revision) return { ready: false, code: 'request-organization-changed' };
|
|
const found = resources(now.document, plan.staff.pm);
|
|
if (found.code) return { ready: false, code: found.code };
|
|
if (plan.tracker.root !== found.root) return { ready: false, code: 'request-tracker-unavailable' };
|
|
if (Object.keys(found.staff).some(k => plan.staff[k] !== found.staff[k])) return { ready: false, code: 'request-staff-unavailable' };
|
|
if (plan.existing) {
|
|
const row = inventory({ business: plan.business, owner: now.document.human, pm: plan.staff.pm }).find(row => row.project === plan.project);
|
|
if (!row || digest(row.tracker) !== digest(plan.tracker)) return { ready: false, code: 'request-existing-project-changed' };
|
|
const mode = journal.projectState(plan.business, plan.project)?.mode ?? 'guided';
|
|
const current = prepareExistingPlan({ business: now.document, request: plan.request, project: plan.project, name: row.name, mode,
|
|
dataRoot, organizationRevision: now.revision, tracker: row.tracker, staff: found.staff, intent: plan.intent, chat_project: plan.chat_project });
|
|
if (digest(current) !== digest(plan)) return { ready: false, code: 'request-existing-project-changed' };
|
|
}
|
|
return { ready: true };
|
|
},
|
|
};
|
|
}
|