shift-ax 0.3.0

package/dist/core/context/glossary.js

@@ -0,0 +1,73 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+function uniq(items) {
+    return [...new Set(items)];
+}
+function scoreTerm(term) {
+    const noSpaces = term.replace(/\s+/g, '');
+    if (/^[A-Z][a-z]+(?:[A-Z][a-z]+)+$/.test(noSpaces))
+        return 3; // CamelCase
+    if (/^[A-Z][a-z]+(?:\s+[A-Z][a-z]+)+$/.test(term))
+        return 2; // Title case phrase
+    if (/^[A-Z][a-z]+(?:[A-Z][A-Za-z0-9]+)+$/.test(term))
+        return 3;
+    return 1;
+}
+function extractCandidateTerms(content) {
+    const candidates = new Set();
+    const headingMatches = content.match(/^#\s+(.+)$/gm) ?? [];
+    for (const match of headingMatches) {
+        candidates.add(match.replace(/^#\s+/, '').trim());
+    }
+    const camelMatches = content.match(/\b[A-Z][a-z]+(?:[A-Z][A-Za-z0-9]+)+\b/g) ?? [];
+    for (const term of camelMatches) {
+        candidates.add(term.trim());
+    }
+    const titlePhraseMatches = content.match(/\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+){1,3}\b/g) ?? [];
+    for (const term of titlePhraseMatches) {
+        candidates.add(term.trim());
+    }
+    return [...candidates]
+        .filter((term) => term.length >= 4)
+        .filter((term) => !['Base Context Index', 'Domain Glossary'].includes(term))
+        .sort((a, b) => scoreTerm(b) - scoreTerm(a) || a.localeCompare(b));
+}
+function buildDefinition(term, sourcePath) {
+    return `Detected from ${sourcePath} as a likely domain or architecture term.`;
+}
+export async function extractDomainGlossaryEntries({ rootDir, documentPaths, }) {
+    const byTerm = new Map();
+    for (const path of documentPaths) {
+        const content = await readFile(join(rootDir, path), 'utf8').catch(() => '');
+        if (!content.trim())
+            continue;
+        for (const term of extractCandidateTerms(content)) {
+            const existing = byTerm.get(term);
+            if (existing) {
+                existing.sources = uniq([...existing.sources, path]);
+                continue;
+            }
+            byTerm.set(term, {
+                term,
+                definition: buildDefinition(term, path),
+                sources: [path],
+            });
+        }
+    }
+    return [...byTerm.values()].sort((a, b) => a.term.localeCompare(b.term));
+}
+export async function writeDomainGlossaryDocument({ rootDir, entries, path = 'docs/base-context/domain-glossary.md', }) {
+    const absolutePath = join(rootDir, path);
+    await mkdir(dirname(absolutePath), { recursive: true });
+    const lines = ['# Domain Glossary', ''];
+    for (const entry of entries) {
+        lines.push(`## ${entry.term}`);
+        lines.push('');
+        lines.push(entry.definition);
+        lines.push('');
+        lines.push(`Sources: ${entry.sources.join(', ')}`);
+        lines.push('');
+    }
+    await writeFile(absolutePath, `${lines.join('\n').trimEnd()}\n`, 'utf8');
+    return { path };
+}

package/dist/core/context/guided-onboarding.js

@@ -0,0 +1,233 @@
+import { access, readdir, readFile } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { isAbsolute, join, resolve } from 'node:path';
+import { onboardProjectContext, } from './onboarding.js';
+import { defaultEngineeringDefaults, } from '../policies/project-profile.js';
+import { getGlobalContextHome } from '../settings/global-context-home.js';
+const COPY = {
+    en: {
+        intro: 'This step matters most. Please invest 10 minutes so Shift AX can understand how you work.',
+        roleSummary: '1. What kind of work do you usually do? ',
+        workTypes: 'List your main work types (comma-separated, e.g. API development, incident response): ',
+        workTypeSummary: (workType) => `Summarize how "${workType}" work usually looks for you: `,
+        repositories: (workType) => `Which repositories are involved in "${workType}"? (comma-separated): `,
+        repositoryPath: (repository, defaultPath) => `What path should Shift AX inspect for "${repository}"? [${defaultPath} or blank if unknown]: `,
+        repositoryPurpose: (repository) => `What does "${repository}" mainly do in your work? `,
+        directories: (workType, repository) => `For "${workType}" in "${repository}", which directories do you touch? (comma-separated): `,
+        inferredWorkflow: (repository, inference) => [
+            `I inspected "${repository}" and inferred this workflow:`,
+            inference,
+            'What is wrong or missing? Be explicit.',
+            '> ',
+        ].join('\n'),
+        confirmedWorkflow: (workType, repository) => `Describe the actual working method for "${workType}" in "${repository}": `,
+        glossaryTerms: 'List company-specific terms or aliases Shift AX should know. (comma-separated): ',
+        glossaryDefinition: (term) => `What does "${term}" mean in your company/domain? `,
+        verificationCommands: 'Which verification commands should Shift AX run by default? (comma-separated)',
+        overwrite: (path) => `Global knowledge already exists at ${path}. Overwrite and back up the previous files? [y/N]: `,
+        shareMessage: (path) => `Onboarding finished. Please share ${path} with teammates who do similar work and ask them to place it in the same location.`,
+    },
+    ko: {
+        intro: '이 절차가 가장 중요합니다. 당신을 잘 이해하기 위해 10분의 시간을 투자해주세요.',
+        roleSummary: '1. 당신은 어떤 업무를 주로 하나요? ',
+        workTypes: '주요 작업 유형을 적어주세요. (쉼표 구분, 예: API 개발, 장애 대응): ',
+        workTypeSummary: (workType) => `"${workType}" 업무는 보통 어떤 식으로 진행되나요? `,
+        repositories: (workType) => `"${workType}" 업무에 관련된 레포는 무엇인가요? (쉼표 구분): `,
+        repositoryPath: (repository, defaultPath) => `"${repository}"를 Shift AX가 어디서 읽어야 하나요? [${defaultPath} 또는 모르면 공백]: `,
+        repositoryPurpose: (repository) => `"${repository}"는 당신의 업무에서 어떤 역할을 하나요? `,
+        directories: (workType, repository) => `"${workType}" 업무를 "${repository}"에서 할 때 주로 만지는 디렉토리는 무엇인가요? (쉼표 구분): `,
+        inferredWorkflow: (repository, inference) => [
+            `"${repository}"를 읽어보고 제가 이렇게 추론했습니다:`,
+            inference,
+            '틀린 부분이나 빠진 부분을 꼭 짚어주세요.',
+            '> ',
+        ].join('\n'),
+        confirmedWorkflow: (workType, repository) => `"${workType}" 업무를 "${repository}"에서 실제로 어떤 절차로 진행하나요? `,
+        glossaryTerms: '회사/도메인에서만 쓰는 용어를 적어주세요. (쉼표 구분): ',
+        glossaryDefinition: (term) => `"${term}"는 무엇인가요? `,
+        verificationCommands: 'Shift AX가 기본으로 돌려야 하는 검증 명령은 무엇인가요? (쉼표 구분)',
+        overwrite: (path) => `${path} 아래에 기존 글로벌 지식이 있습니다. 이전 파일을 백업하고 덮어쓸까요? [y/N]: `,
+        shareMessage: (path) => `온보딩이 끝났습니다. 비슷한 업무를 하는 동료에게 ${path} 를 공유하고 같은 위치에 넣어달라고 안내해주세요.`,
+    },
+};
+function normalizeCommaList(value) {
+    return value
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+async function pathExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function homeHasExistingKnowledge() {
+    const home = getGlobalContextHome();
+    return ((await pathExists(home.indexPath)) ||
+        (await pathExists(home.profilePath)) ||
+        (await pathExists(home.settingsPath)));
+}
+async function promptNonEmpty(ask, question) {
+    while (true) {
+        const answer = (await ask(question)).trim();
+        if (answer)
+            return answer;
+    }
+}
+async function promptWithDefault(ask, question, defaultValue) {
+    const answer = (await ask(`${question} [${defaultValue}]: `)).trim();
+    return answer || defaultValue;
+}
+async function listInterestingFiles(rootDir, directories) {
+    const candidates = directories.length > 0 ? directories : ['.'];
+    const interesting = [];
+    for (const directory of candidates.slice(0, 6)) {
+        const absolute = resolve(rootDir, directory);
+        if (!(await pathExists(absolute)))
+            continue;
+        const entries = await readdir(absolute, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries.slice(0, 20)) {
+            if (entry.name.startsWith('.'))
+                continue;
+            const relative = directory === '.' ? entry.name : join(directory, entry.name);
+            if (entry.isDirectory()) {
+                if (/controller|service|dto|schema|prisma|route|api|worker|job/i.test(entry.name)) {
+                    interesting.push(relative);
+                }
+            }
+            else if (/\.(ts|tsx|js|jsx|prisma|sql|md|yaml|yml)$/.test(entry.name)) {
+                interesting.push(relative);
+            }
+            if (interesting.length >= 8)
+                return interesting;
+        }
+    }
+    return interesting;
+}
+async function inferWorkflow({ rootDir, repository, directories, }) {
+    const interestingFiles = await listInterestingFiles(rootDir, directories);
+    const heuristics = [];
+    const haystack = interestingFiles.join(' ');
+    if (/controller/i.test(haystack) && /service/i.test(haystack)) {
+        heuristics.push('It looks like controller/service boundaries matter here.');
+    }
+    if (/dto/i.test(haystack)) {
+        heuristics.push('DTO definitions appear to be part of the change flow.');
+    }
+    if (/prisma/i.test(haystack)) {
+        heuristics.push('It looks like Prisma schema files may define database changes here.');
+    }
+    if (/worker|job/i.test(haystack)) {
+        heuristics.push('There appear to be worker/job paths that may need runtime or queue-specific handling.');
+    }
+    let excerpt = '';
+    const firstInterestingFile = interestingFiles.find((path) => /\.(ts|tsx|js|jsx|prisma)$/.test(path));
+    if (firstInterestingFile) {
+        excerpt = await readFile(resolve(rootDir, firstInterestingFile), 'utf8')
+            .then((content) => content.slice(0, 220).trim())
+            .catch(() => '');
+    }
+    return [
+        `Repository: ${repository}`,
+        directories.length > 0 ? `Directories: ${directories.join(', ')}` : 'Directories: none recorded yet.',
+        interestingFiles.length > 0
+            ? `Observed files/dirs: ${interestingFiles.join(', ')}`
+            : 'Observed files/dirs: none',
+        heuristics.length > 0 ? `Inferences: ${heuristics.join(' ')}` : 'Inferences: no strong file-pattern inference yet.',
+        excerpt ? `First code excerpt hint: ${excerpt}` : '',
+    ]
+        .filter(Boolean)
+        .join('\n');
+}
+async function buildRepositoryInput({ ask, locale, rootDir, workType, repository, defaultPath, }) {
+    const copy = COPY[locale];
+    const requestedPath = (await ask(copy.repositoryPath(repository, defaultPath))).trim();
+    const repositoryPath = requestedPath === ''
+        ? defaultPath
+        : isAbsolute(requestedPath)
+            ? requestedPath
+            : resolve(rootDir, requestedPath);
+    const purpose = await promptNonEmpty(ask, copy.repositoryPurpose(repository));
+    const directories = normalizeCommaList(await ask(copy.directories(workType, repository)));
+    const inference = await inferWorkflow({
+        rootDir: repositoryPath,
+        repository,
+        directories,
+    });
+    const correction = await ask(copy.inferredWorkflow(repository, inference));
+    const workflow = await promptNonEmpty(ask, copy.confirmedWorkflow(workType, repository));
+    return {
+        repository,
+        repositoryPath,
+        purpose,
+        directories,
+        workflow,
+        inferredNotes: correction.trim() ? [correction.trim()] : [inference],
+        confirmationNotes: correction.trim() || 'User accepted the inferred workflow with no further edits.',
+        volatility: 'volatile',
+    };
+}
+export async function runGuidedOnboarding({ rootDir, locale, ask, }) {
+    const copy = COPY[locale];
+    const defaults = defaultEngineeringDefaults();
+    const home = getGlobalContextHome();
+    await ask(`${copy.intro}\n\n(press Enter to continue)\n> `);
+    const primaryRoleSummary = await promptNonEmpty(ask, copy.roleSummary);
+    const workTypeNames = normalizeCommaList(await promptNonEmpty(ask, copy.workTypes));
+    const workTypes = [];
+    for (const workType of workTypeNames) {
+        const summary = await promptNonEmpty(ask, copy.workTypeSummary(workType));
+        const repositories = normalizeCommaList(await promptNonEmpty(ask, copy.repositories(workType)));
+        const repositoryInputs = [];
+        for (let index = 0; index < repositories.length; index += 1) {
+            const repository = repositories[index];
+            repositoryInputs.push(await buildRepositoryInput({
+                ask,
+                locale,
+                rootDir,
+                workType,
+                repository,
+                defaultPath: index === 0 ? rootDir : '',
+            }));
+        }
+        workTypes.push({
+            name: workType,
+            summary,
+            repositories: repositoryInputs,
+        });
+    }
+    const glossaryTerms = normalizeCommaList(await ask(copy.glossaryTerms));
+    const domainLanguage = [];
+    for (const term of glossaryTerms) {
+        domainLanguage.push({
+            term,
+            definition: await promptNonEmpty(ask, copy.glossaryDefinition(term)),
+        });
+    }
+    const verificationCommands = normalizeCommaList(await promptWithDefault(ask, copy.verificationCommands, defaults.verification_commands?.join(', ') || 'npm test, npm run build'));
+    const overwriteAnswer = (await homeHasExistingKnowledge())
+        ? (await ask(copy.overwrite(home.root))).trim().toLowerCase()
+        : 'y';
+    const result = await onboardProjectContext({
+        rootDir,
+        primaryRoleSummary,
+        workTypes,
+        domainLanguage,
+        onboardingContext: {
+            primary_role_summary: primaryRoleSummary,
+            work_types: workTypes.map((item) => item.name),
+            domain_language: domainLanguage.map((item) => item.term),
+        },
+        engineeringDefaults: {
+            ...defaults,
+            verification_commands: verificationCommands.length > 0 ? verificationCommands : defaults.verification_commands,
+        },
+        overwrite: ['y', 'yes'].includes(overwriteAnswer),
+    });
+    process.stderr.write(`${copy.shareMessage(result.sharePath)}\n`);
+    return result;
+}

package/dist/core/context/index-authoring.js

@@ -0,0 +1,47 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { parseIndexDocument, } from './index-resolver.js';
+function dedupeEntries(entries) {
+    const seen = new Set();
+    const result = [];
+    for (const entry of entries) {
+        const key = `${entry.label}::${entry.path}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(entry);
+    }
+    return result;
+}
+export function renderIndexDocument(entries) {
+    const lines = ['# Base Context Index', ''];
+    for (const entry of entries) {
+        lines.push(`- ${entry.label} -> ${entry.path}`);
+    }
+    lines.push('');
+    lines.push('Notes:');
+    lines.push('');
+    lines.push('- each line should point to a concrete tracked document');
+    lines.push('- documents in this directory are shared and versioned');
+    lines.push('- request-local planning or review artifacts should not live here');
+    lines.push('');
+    return lines.join('\n');
+}
+export async function authorBaseContextIndex({ rootDir, indexPath = join(rootDir, 'docs', 'base-context', 'index.md'), entries, }) {
+    if (!rootDir)
+        throw new Error('rootDir is required');
+    let existing = [];
+    try {
+        existing = parseIndexDocument(await readFile(indexPath, 'utf8'));
+    }
+    catch {
+        existing = [];
+    }
+    const merged = dedupeEntries([...existing, ...entries]);
+    await mkdir(join(rootDir, 'docs', 'base-context'), { recursive: true });
+    await writeFile(indexPath, renderIndexDocument(merged), 'utf8');
+    return {
+        indexPath,
+        entries: merged,
+    };
+}

package/dist/core/context/index-resolver.js

@@ -0,0 +1,78 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+function tokenize(value) {
+    return String(value || '')
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length >= 3);
+}
+export function parseIndexDocument(markdown) {
+    const lines = String(markdown || '').split(/\r?\n/);
+    const entries = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('-'))
+            continue;
+        const body = trimmed.slice(1).trim();
+        const match = body.match(/^(.+?)\s*->\s*(.+)$/);
+        if (!match)
+            continue;
+        entries.push({
+            label: match[1].trim(),
+            path: match[2].trim(),
+        });
+    }
+    return entries;
+}
+function scoreEntry(entry, queryTokens) {
+    const haystack = new Set([...tokenize(entry.label), ...tokenize(entry.path)]);
+    let score = 0;
+    for (const token of queryTokens) {
+        if (haystack.has(token))
+            score += 1;
+    }
+    return score;
+}
+export async function resolveContextFromIndex({ rootDir, indexPath, indexRootDir, query, maxMatches = 5, }) {
+    if (!rootDir)
+        throw new Error('rootDir is required');
+    if (!indexPath)
+        throw new Error('indexPath is required');
+    if (!query || String(query).trim() === '')
+        throw new Error('query is required');
+    const rawIndex = await readFile(indexPath, 'utf8');
+    const entries = parseIndexDocument(rawIndex);
+    const queryTokens = tokenize(query);
+    const scored = entries
+        .map((entry) => ({ entry, score: scoreEntry(entry, queryTokens) }))
+        .filter((item) => item.score > 0)
+        .sort((left, right) => right.score - left.score)
+        .slice(0, maxMatches);
+    const matches = [];
+    const unresolvedPaths = [];
+    const effectiveIndexRootDir = indexRootDir || rootDir;
+    for (const item of scored) {
+        const absolutePath = resolve(effectiveIndexRootDir, item.entry.path);
+        try {
+            const content = await readFile(absolutePath, 'utf8');
+            matches.push({
+                label: item.entry.label,
+                path: item.entry.path,
+                absolute_path: absolutePath,
+                score: item.score,
+                content,
+            });
+        }
+        catch {
+            unresolvedPaths.push(item.entry.path);
+        }
+    }
+    return {
+        version: 1,
+        index_path: indexPath,
+        query: String(query).trim(),
+        matches,
+        unresolved_paths: unresolvedPaths,
+    };
+}

package/dist/core/context/onboarding.js

@@ -0,0 +1,186 @@
+import { access, cp, mkdir, readFile } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { basename, join, relative } from 'node:path';
+import { authorGlobalKnowledgeBase, } from './global-index-authoring.js';
+import { discoverBaseContextEntries } from './discovery.js';
+import { defaultEngineeringDefaults, writeProjectProfile, } from '../policies/project-profile.js';
+import { getGlobalContextHome } from '../settings/global-context-home.js';
+async function pathExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function slugify(value) {
+    return String(value || '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '') || 'context';
+}
+function deriveLegacyWorkTypes({ rootDir, documents, }) {
+    const repoName = basename(rootDir);
+    return [
+        {
+            name: 'Repository Context',
+            summary: 'Migrated legacy repository-local context.',
+            repositories: [
+                {
+                    repository: repoName,
+                    repositoryPath: rootDir,
+                    directories: documents.map((document) => document.path || `docs/base-context/${slugify(document.label)}.md`),
+                    workflow: documents
+                        .map((document) => `${document.label}: ${document.content.replace(/^# .*$/m, '').trim()}`)
+                        .join('\n\n'),
+                    volatility: 'volatile',
+                },
+            ],
+        },
+    ];
+}
+function deriveLegacyDomainLanguage(documents) {
+    return documents.map((document) => ({
+        term: document.label,
+        definition: `Migrated legacy context entry stored under ${document.path || `docs/base-context/${slugify(document.label)}.md`}.`,
+    }));
+}
+async function backupFileIfPresent(path) {
+    const home = getGlobalContextHome();
+    if (!(await pathExists(path)))
+        return;
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    await mkdir(home.backupsDir, { recursive: true });
+    const backupName = `${stamp}-${basename(path)}`;
+    await cp(path, join(home.backupsDir, backupName));
+}
+async function ensureOverwriteAllowed({ overwrite, candidatePaths, }) {
+    if (!overwrite) {
+        for (const path of candidatePaths) {
+            if (await pathExists(path)) {
+                throw new Error(`global context file already exists and requires overwrite confirmation: ${path}`);
+            }
+        }
+        return;
+    }
+    for (const path of candidatePaths) {
+        await backupFileIfPresent(path);
+    }
+}
+function normalizeOnboardingContext({ primaryRoleSummary, workTypes, domainLanguage, onboardingContext, }) {
+    return (onboardingContext ?? {
+        primary_role_summary: primaryRoleSummary,
+        work_types: workTypes.map((workType) => workType.name),
+        domain_language: domainLanguage.map((entry) => entry.term),
+    });
+}
+export async function persistProjectContextProfile({ rootDir, entries, onboardingContext, engineeringDefaults, now, }) {
+    const home = getGlobalContextHome();
+    const profile = {
+        version: 1,
+        updated_at: now.toISOString(),
+        docs_root: home.root,
+        index_path: relative(home.root, home.indexPath) || 'index.md',
+        context_docs: entries,
+        ...(onboardingContext ? { onboarding_context: onboardingContext } : {}),
+        engineering_defaults: engineeringDefaults,
+    };
+    await writeProjectProfile(rootDir, profile);
+    return {
+        index: {
+            indexPath: home.indexPath,
+            entries,
+        },
+        profile,
+    };
+}
+export async function onboardProjectContext({ rootDir, primaryRoleSummary, workTypes, domainLanguage, onboardingContext, engineeringDefaults = defaultEngineeringDefaults(), overwrite = true, documents, }) {
+    if (!rootDir)
+        throw new Error('rootDir is required');
+    const derivedWorkTypes = workTypes && workTypes.length > 0
+        ? workTypes
+        : documents && documents.length > 0
+            ? deriveLegacyWorkTypes({ rootDir, documents })
+            : [];
+    const derivedDomainLanguage = domainLanguage && domainLanguage.length > 0
+        ? domainLanguage
+        : documents && documents.length > 0
+            ? deriveLegacyDomainLanguage(documents)
+            : [];
+    const derivedPrimaryRoleSummary = primaryRoleSummary?.trim() ||
+        onboardingContext?.primary_role_summary?.trim() ||
+        `Primary workflow owner for ${basename(rootDir)}.`;
+    if (derivedWorkTypes.length === 0) {
+        throw new Error('workTypes are required');
+    }
+    const home = getGlobalContextHome();
+    const candidatePaths = [
+        home.indexPath,
+        home.profilePath,
+        home.settingsPath,
+        ...derivedWorkTypes.flatMap((workType) => [
+            join(home.workTypesDir, `${slugify(workType.name)}.md`),
+            ...workType.repositories.map((repository) => join(home.reposDir, `${slugify(repository.repository || basename(repository.repositoryPath || 'repo'))}.md`)),
+            ...workType.repositories.map((repository) => join(home.proceduresDir, `${slugify(workType.name)}--${slugify(repository.repository || basename(repository.repositoryPath || 'repo'))}.md`)),
+        ]),
+        ...derivedDomainLanguage.map((entry) => join(home.domainLanguageDir, `${slugify(entry.term)}.md`)),
+    ];
+    await ensureOverwriteAllowed({
+        overwrite,
+        candidatePaths,
+    });
+    const index = await authorGlobalKnowledgeBase({
+        primaryRoleSummary: derivedPrimaryRoleSummary,
+        workTypes: derivedWorkTypes,
+        domainLanguage: derivedDomainLanguage,
+    });
+    const { profile } = await persistProjectContextProfile({
+        rootDir,
+        entries: index.contextDocs,
+        onboardingContext: normalizeOnboardingContext({
+            primaryRoleSummary: derivedPrimaryRoleSummary,
+            workTypes: derivedWorkTypes,
+            domainLanguage: derivedDomainLanguage,
+            onboardingContext,
+        }),
+        engineeringDefaults,
+        now: new Date(),
+    });
+    return {
+        documents: index.contextDocs,
+        index: {
+            indexPath: index.indexPath,
+            entries: index.contextDocs,
+        },
+        profile,
+        sharePath: home.root,
+    };
+}
+export async function onboardProjectContextFromDiscovery({ rootDir, onboardingContext, engineeringDefaults = defaultEngineeringDefaults(), includeGlossary = false, overwrite = true, }) {
+    const discovered = await discoverBaseContextEntries({ rootDir });
+    if (discovered.length === 0) {
+        throw new Error('no discoverable base-context documents were found');
+    }
+    const documents = await Promise.all(discovered.map(async (entry) => ({
+        label: entry.label,
+        path: entry.path,
+        content: await readFile(join(rootDir, entry.path), 'utf8'),
+    })));
+    const domainLanguage = includeGlossary
+        ? discovered.map((entry) => ({
+            term: entry.label,
+            definition: `Migrated from ${entry.path}.`,
+        }))
+        : [];
+    return onboardProjectContext({
+        rootDir,
+        documents,
+        domainLanguage,
+        onboardingContext,
+        engineeringDefaults,
+        overwrite,
+    });
+}