engineering-memory 1.10.2 → 1.10.4

package/runtime/dist/src/mcp/questionnaire-tools.js

@@ -0,0 +1,149 @@
+import { acceptedContent, CLIENT_CAPABILITIES_META_KEY, inputRequired, inputResponse, } from '@modelcontextprotocol/server';
+import { questionnaireAnswerSchema, } from '../runtime/questionnaire-store.js';
+export async function askQuestionnaire(server, service, input, context) {
+    try {
+        return await present(server, service, await service.questionnaireAsk(input), input.repoRoot, context, input.preparation);
+    }
+    catch (error) {
+        return failure(error);
+    }
+}
+export async function resumeQuestionnaire(server, service, input, context) {
+    try {
+        return await present(server, service, await service.questionnaireResume(input), input.repoRoot, context, input.preparation);
+    }
+    catch (error) {
+        return failure(error);
+    }
+}
+async function present(server, service, record, repoRoot, context, preparation) {
+    if (record.status === 'withdrawn')
+        return result({
+            questionnaireId: record.questionnaireId,
+            status: 'withdrawn',
+            answerAvailable: false,
+            nextAction: 'This decision was explicitly withdrawn. Do not continue dependent work. Use a new questionnaireId or onboarding requestKey only if the user resumes that work.',
+        });
+    if (record.status === 'answered')
+        return answered(record, record.answer, true);
+    if (context.mcpReq.signal.aborted)
+        return pending(record, 'interrupted');
+    const responses = context.mcpReq.inputResponses;
+    const response = inputResponse(responses, record.requestKey);
+    if (response.kind === 'elicit' && response.action === 'accept') {
+        const answer = acceptedContent(responses, record.requestKey, questionnaireAnswerSchema(record));
+        if (!answer)
+            return pending(record, 'invalid_response');
+        const resolved = await service.questionnaireAccept({
+            repoRoot,
+            preparation,
+            questionnaireId: record.questionnaireId,
+            requestKey: record.requestKey,
+            scope: record.scope,
+            answer,
+        });
+        return answered(resolved.record, resolved.answer, resolved.replayed);
+    }
+    if (response.kind === 'elicit')
+        return pending(record, response.action);
+    if (responses !== undefined || context.mcpReq.droppedInputResponseKeys?.length)
+        return pending(record, 'missing_or_stale_response');
+    const envelope = context.mcpReq.envelope;
+    const capabilities = envelope?.[CLIENT_CAPABILITIES_META_KEY] ?? server.server.getClientCapabilities();
+    const elicitation = capabilities?.elicitation;
+    if (!elicitation || (!elicitation.form && elicitation.url !== undefined))
+        return pending(record, 'native_form_unavailable');
+    return inputRequired({
+        inputRequests: {
+            [record.requestKey]: inputRequired.elicit({
+                mode: 'form',
+                message: `${record.message}\n\nChoose an answer to resolve this decision. Closing or cancelling the form leaves it pending.${record.allowFreeText ? ' For another answer choose Other and fill in text. Free text is not stored and cannot be replayed.' : ''}${record.textField ? ' The bounded text field is stored as part of this exact decision and is replayed after restart.' : ''}`,
+                requestedSchema: {
+                    type: 'object',
+                    properties: {
+                        choice: {
+                            type: 'string',
+                            title: 'Answer',
+                            enum: [
+                                ...record.options.map((option) => option.id),
+                                ...(record.allowFreeText ? ['__other__'] : []),
+                            ],
+                            enumNames: [
+                                ...record.options.map((option) => option.label),
+                                ...(record.allowFreeText ? ['Other'] : []),
+                            ],
+                        },
+                        ...(record.allowFreeText
+                            ? {
+                                text: {
+                                    type: 'string',
+                                    title: 'Other answer',
+                                    minLength: 1,
+                                    maxLength: 2000,
+                                },
+                            }
+                            : {}),
+                        ...(record.textField
+                            ? {
+                                text: {
+                                    type: 'string',
+                                    title: record.textField.title,
+                                    minLength: 1,
+                                    maxLength: record.textField.maxLength,
+                                },
+                            }
+                            : {}),
+                    },
+                    required: ['choice'],
+                },
+            }),
+        },
+    });
+}
+function pending(record, reason) {
+    return result({
+        questionnaireId: record.questionnaireId,
+        status: 'pending',
+        reason,
+        answerAvailable: false,
+        nextAction: reason === 'native_form_unavailable'
+            ? 'This host does not advertise native MCP forms. The decision remains pending. Explain the limitation and continue only independently authorized work. Use a supported native host and questionnaire.resume to answer; do not silently substitute an asynchronous question.'
+            : 'The decision remains pending without expiry. Call questionnaire.resume with this questionnaireId to show the same question again. Do not infer an answer or continue dependent work.',
+    });
+}
+function answered(record, answer, replayed) {
+    return result({
+        questionnaireId: record.questionnaireId,
+        status: 'answered',
+        answerAvailable: answer !== undefined,
+        ...(answer ? { answer } : {}),
+        replayed,
+        ...(!answer
+            ? {
+                nextAction: 'The free-text answer was accepted earlier but was not stored for privacy. It cannot be recovered or inferred. Use the original answer if still present in this conversation; otherwise collect it again through a new questionnaire or supported native input before dependent work.',
+            }
+            : {}),
+    });
+}
+function result(data) {
+    return { content: [{ type: 'text', text: JSON.stringify({ ok: true, data }) }] };
+}
+function failure(error) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    ok: false,
+                    error: {
+                        kind: 'questionnaire_error',
+                        message: error instanceof Error ? error.message : 'Questionnaire operation failed.',
+                        recovery: 'session.entry',
+                    },
+                }),
+            },
+        ],
+        isError: true,
+    };
+}
+//# sourceMappingURL=questionnaire-tools.js.map

package/runtime/dist/src/mcp/server.js

@@ -1,11 +1,14 @@
 import { McpServer } from '@modelcontextprotocol/server';
-import { registerEngineeringMemoryTools } from './tool-definitions.js';
+import { registerOnboardingTools } from './onboarding-tools.js';
+import { registerEngineeringMemoryTools, registerQuestionnaireTools } from './tool-definitions.js';
 export function createEngineeringMemoryServer(service) {
     const server = new McpServer({
         name: 'engineering-memory',
         version: '0.1.0',
     });
     registerEngineeringMemoryTools(server, service);
+    registerQuestionnaireTools(server, service);
+    registerOnboardingTools(server, service);
     return server;
 }
 //# sourceMappingURL=server.js.map

package/runtime/dist/src/mcp/tool-definitions.js

@@ -1,5 +1,7 @@
 import * as z from 'zod/v4';
 import { validationIds } from '../runtime/bridge-service.js';
+import { questionnaireDefinitionSchema } from '../runtime/questionnaire-store.js';
+import { askQuestionnaire, resumeQuestionnaire } from './questionnaire-tools.js';
 const optionalRepoRoot = z.string().min(1).optional();
 const stringList = z.array(z.string().min(1));
 const jsonValue = z.lazy(() => z.union([
@@ -45,6 +47,9 @@ const checkpointBase = {
 };
 export const engineeringMemoryToolNames = [
     'audit.list',
+    'questionnaire.ask',
+    'questionnaire.resume',
+    'questionnaire.withdraw',
     'session.entry',
     'session.set_decision',
     'session.decline_update',
@@ -53,6 +58,24 @@ export const engineeringMemoryToolNames = [
     'session.resume',
     'context.prepare_change',
     'context.refresh',
+    'project.inspect',
+    'project.onboard',
+    'project.onboarding_status',
+    'project.rework_plan',
+    'project.initialize',
+    'memory.source',
+    'memory.sync_start',
+    'memory.sync_status',
+    'memory.sync_inventory',
+    'memory.sync_plan',
+    'memory.sync_next',
+    'memory.sync_submit',
+    'memory.sync_reopen',
+    'memory.sync_delta',
+    'memory.sync_verify',
+    'memory.catalog',
+    'memory.read_revisions',
+    'memory.review_batch',
     'memory.query',
     'memory.history',
     'memory.propose_revision',
@@ -116,6 +139,53 @@ const reconciliationEntry = z.object({
     revisionId: z.string().optional(),
     reason: z.string().optional(),
 });
+export function registerQuestionnaireTools(server, service) {
+    server.registerTool('questionnaire.withdraw', {
+        description: 'Withdraw a pending decision only when the user explicitly cancels that decision or its owning workflow. This is not approval. An answered decision is immutable. Interruption, timeout and dismissal alone never authorize withdrawal.',
+        inputSchema: z.strictObject({
+            repoRoot: optionalRepoRoot,
+            questionnaireId: z.string().regex(/^[A-Za-z0-9_-]{1,100}$/),
+            preparation: z.boolean().optional(),
+        }),
+    }, async (input) => {
+        try {
+            const record = await service.questionnaireWithdraw(input);
+            return toolResult({
+                ok: true,
+                data: {
+                    questionnaireId: record.questionnaireId,
+                    status: record.status,
+                    answerAvailable: record.answerAvailable ?? false,
+                },
+            });
+        }
+        catch {
+            return toolResult({
+                ok: false,
+                error: {
+                    kind: 'bridge_error',
+                    message: 'Cannot withdraw this questionnaire. Check the account and repository with session.entry and the exact questionnaireId with questionnaire.resume.',
+                    retryable: false,
+                },
+            });
+        }
+    });
+    server.registerTool('questionnaire.ask', {
+        description: 'Persist a required decision before displaying a native questionnaire. Use a questionnaireId unique to this decision occurrence or task, and reuse it only for identical retries. A later decision or changed wording/options requires a new id. Only a schema-validated native acceptance answers it. Dismissal, timeout and missing replies remain pending without expiry. Never supply answers in tool arguments. Do not put personal information or secrets in the question or options. Free text is returned once and never stored; use explicit options for replayable decisions.',
+        inputSchema: questionnaireDefinitionSchema.extend({
+            repoRoot: optionalRepoRoot,
+            preparation: z.boolean().optional(),
+        }),
+    }, async (input, context) => await askQuestionnaire(server, service, input, context));
+    server.registerTool('questionnaire.resume', {
+        description: 'Display the original durable questionnaire after interruption or return its saved accepted choice. No timeout or dismissal resolves a pending question. A saved free-text receipt cannot replay the text and must never be treated as a recovered answer.',
+        inputSchema: z.strictObject({
+            repoRoot: optionalRepoRoot,
+            questionnaireId: z.string().regex(/^[A-Za-z0-9_-]{1,100}$/),
+            preparation: z.boolean().optional(),
+        }),
+    }, async (input, context) => await resumeQuestionnaire(server, service, input, context));
+}
 export function registerEngineeringMemoryTools(server, service) {
     server.registerTool('audit.list', {
         description: 'List one authorized organization or project audit trail with an exact cursor. Choose exactly one scope and send both cursor fields together.',
@@ -269,6 +339,7 @@ export function registerEngineeringMemoryTools(server, service) {
             tags: stringList.optional(),
             metadata: jsonObject.optional(),
             provenance: jsonObject.optional(),
+            status: z.enum(['active', 'archived']).optional(),
         }),
     }, async (input) => toolResult(await service.memoryProposeRevision(input)));
     server.registerTool('memory.list_proposals', {

package/runtime/dist/src/project/project-intake.js

@@ -0,0 +1,406 @@
+import { lstat, readFile, readdir } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { canonicalPath, ensureManagedDirectory } from '../utilities/files.js';
+import { NativeCommandRunner } from '../utilities/process.js';
+export class ProjectIntake {
+    runner;
+    constructor(runner = new NativeCommandRunner()) {
+        this.runner = runner;
+    }
+    async inspect(repoPath) {
+        const requested = resolve(repoPath);
+        let root;
+        try {
+            const requestedInfo = await lstat(requested);
+            if (requestedInfo.isSymbolicLink())
+                throw new Error('Project path must not be a symbolic link');
+            root = await canonicalPath(requested);
+            const info = await lstat(root);
+            if (!info.isDirectory() || info.isSymbolicLink())
+                throw new Error('Project path must be a real directory');
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                'code' in error &&
+                error.code === 'ENOENT') {
+                return emptyReport(requested, 'missing', ['directory does not exist']);
+            }
+            throw error;
+        }
+        const entries = await readdir(root, { withFileTypes: true });
+        if (entries.length === 0)
+            return emptyReport(root, 'empty', ['directory exists and is empty']);
+        const inventory = await collectInventory(root);
+        const evidence = [];
+        const stacks = [];
+        for (const detected of await detectStacks(root, inventory.manifestCandidates)) {
+            if (stacks.includes(detected.stack))
+                continue;
+            stacks.push(detected.stack);
+            evidence.push(detected.evidence);
+        }
+        const hasGit = await this.runner.run('git', ['rev-parse', '--is-inside-work-tree'], {
+            cwd: root,
+        });
+        const applicationAreas = [
+            'state',
+            'services',
+            'network',
+            'persistence',
+            'architecture',
+            'screens',
+            'components',
+            'navigation',
+        ].filter((area) => inventory.areaCounts[area] > 0);
+        const hasApplicationAreas = applicationAreas.length > 0;
+        if (hasApplicationAreas)
+            evidence.push(`application structural sources found in ${applicationAreas.join(', ')}`);
+        const recommendation = hasApplicationAreas
+            ? 'established'
+            : meaningfulEntries(entries).length === 0
+                ? 'empty'
+                : 'scaffold';
+        const reasons = stacks.length > 0
+            ? hasApplicationAreas
+                ? [`detected ${stacks.join(', ')} with application structural evidence`]
+                : [`detected ${stacks.join(', ')} without application structural evidence`]
+            : hasApplicationAreas
+                ? [`application structural sources found in ${applicationAreas.join(', ')}`]
+                : meaningfulEntries(entries).length === 0
+                    ? ['directory contains only Git metadata']
+                    : hasGit.exitCode === 0
+                        ? [
+                            'Git repository has no recognized stack manifest or application architectural signals',
+                        ]
+                        : [
+                            'directory has content but no recognized stack manifest or application architectural signals',
+                        ];
+        return { repoPath: root, recommendation, reasons, stacks, evidence, inventory };
+    }
+    async initialize(repoPath) {
+        const requested = resolve(repoPath);
+        await assertNoRepositoryAncestor(requested, this.runner);
+        let exists = true;
+        try {
+            const requestedInfo = await lstat(requested);
+            if (requestedInfo.isSymbolicLink())
+                throw new Error('Project path must not be a symbolic link');
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                'code' in error &&
+                error.code === 'ENOENT')
+                exists = false;
+            else
+                throw error;
+        }
+        if (!exists) {
+            await ensureManagedDirectory(dirname(requested), requested);
+        }
+        const root = await canonicalPath(requested);
+        const info = await lstat(root);
+        if (!info.isDirectory() || info.isSymbolicLink())
+            throw new Error('Project path must be a real directory');
+        const parentGit = await this.runner.run('git', ['rev-parse', '--show-toplevel'], { cwd: root });
+        if (parentGit.exitCode === 0 && resolve(parentGit.stdout.trim()) !== root)
+            throw new Error('Refusing to initialize inside an existing parent repository');
+        const gitPath = join(root, '.git');
+        const existingGit = await lstat(gitPath).then((entry) => {
+            if (entry.isSymbolicLink())
+                throw new Error('Refusing to use a symbolic-link .git path');
+            return true;
+        }, (error) => (error.code === 'ENOENT' ? false : Promise.reject(error)));
+        if (existingGit)
+            return { repoPath: root, initialized: false };
+        const result = await this.runner.run('git', ['init', '--quiet', '--'], { cwd: root });
+        if (result.exitCode !== 0)
+            throw new Error(`Git initialization failed: ${result.stderr.trim()}`);
+        return { repoPath: root, initialized: true };
+    }
+}
+function emptyReport(repoPath, recommendation, reasons) {
+    return {
+        repoPath,
+        recommendation,
+        reasons,
+        stacks: [],
+        evidence: [],
+        inventory: {
+            all: [],
+            state: [],
+            services: [],
+            network: [],
+            persistence: [],
+            architecture: [],
+            screens: [],
+            components: [],
+            navigation: [],
+            symlinks: [],
+            totalFiles: 0,
+            omittedFiles: 0,
+            prunedDirectories: [],
+            prunedDirectoryCount: 0,
+            omittedPrunedDirectories: 0,
+            sampleLimit: INVENTORY_SAMPLE_LIMIT,
+            areaCounts: emptyAreaCounts(),
+            manifestCandidates: [],
+            manifestCandidatesOmitted: 0,
+        },
+    };
+}
+async function collectInventory(root) {
+    const all = [];
+    const state = [];
+    const services = [];
+    const network = [];
+    const persistence = [];
+    const architecture = [];
+    const screens = [];
+    const components = [];
+    const navigation = [];
+    const symlinks = [];
+    const prunedDirectories = [];
+    let prunedDirectoryCount = 0;
+    const areaCounts = emptyAreaCounts();
+    const manifestCandidates = [];
+    let manifestCandidatesOmitted = 0;
+    let totalFiles = 0;
+    const walk = async (directory) => {
+        for (const entry of await readdir(directory, { withFileTypes: true })) {
+            if (entry.name === '.git')
+                continue;
+            const path = join(directory, entry.name);
+            const relativePath = path.slice(root.length + 1).replace(/\\/g, '/');
+            if (entry.isSymbolicLink()) {
+                if (symlinks.length < INVENTORY_SAMPLE_LIMIT) {
+                    all.push(relativePath);
+                    symlinks.push(relativePath);
+                }
+                continue;
+            }
+            if (entry.isDirectory()) {
+                if (await shouldPruneDirectory(root, relativePath)) {
+                    prunedDirectoryCount += 1;
+                    if (prunedDirectories.length < INVENTORY_SAMPLE_LIMIT)
+                        prunedDirectories.push(relativePath);
+                    continue;
+                }
+                await walk(path);
+                continue;
+            }
+            totalFiles += 1;
+            const sampled = totalFiles <= INVENTORY_SAMPLE_LIMIT;
+            if (sampled)
+                all.push(relativePath);
+            const lower = relativePath.toLowerCase();
+            if (['package.json', 'pubspec.yaml', 'pom.xml', 'build.gradle', 'build.gradle.kts'].includes(entry.name.toLowerCase())) {
+                if (manifestCandidates.length < MANIFEST_CANDIDATE_LIMIT)
+                    manifestCandidates.push(relativePath);
+                else
+                    manifestCandidatesOmitted += 1;
+            }
+            const addArea = (area, target) => {
+                areaCounts[area] += 1;
+                if (target.length < INVENTORY_SAMPLE_LIMIT)
+                    target.push(relativePath);
+            };
+            if (/(^|\/)(architecture|adr|adrs|design|docs?)(\/|\.|$)|(^|\/)(architecture|adr)[^/]*\.(md|ya?ml|json)$/.test(lower))
+                addArea('architecture', architecture);
+            if (!entry.isFile() ||
+                !/\.(?:[cm]?[jt]sx?|dart|java|kt|kts|swift|cs|go|rs|py|rb|vue|svelte|openapi|graphql)$/.test(lower) ||
+                /(^|\/)(node_modules|vendor|pods|\.dart_tool|\.next|\.nuxt)(\/|$)|\.(g|freezed)\.dart$|(^|\/)(__tests__|tests?|spec)(\/|$)|\.(test|spec)\.[^/]+$|_test\.[^/]+$/.test(lower) ||
+                isCredentialDataPath(lower))
+                continue;
+            if (/(^|\/)(state|store|stores|reducers?|providers?|bloc|cubits?)(\/|\.|$)|(?:state|store|reducer|provider|bloc|cubit)\.[^/]+$/.test(lower))
+                addArea('state', state);
+            if (/(^|\/)(service|services|use-cases?|usecases|domain)(\/|\.|$)|service\.[^/]+$/.test(lower))
+                addArea('services', services);
+            if (/(^|\/)(api|apis|network|http|graphql|routes?|controllers?|clients?)(\/|\.|$)|(?:controller|client)\.[^/]+$|\.(openapi|graphql)$/.test(lower))
+                addArea('network', network);
+            if (/(^|\/)(persistence|repositories?|storage|database|db|migrations?|entities|models?)(\/|\.|$)|(?:repository|entity|model)\.[^/]+$/.test(lower))
+                addArea('persistence', persistence);
+            if (/(^|\/)(screens?|pages?|views?)(\/|\.|$)|(^|\/)[^/]*(?:screen|page|view)\.[^/]+$/.test(lower))
+                addArea('screens', screens);
+            if (/(^|\/)(components?|widgets?)(\/|\.|$)|(^|\/)[^/]*component\.[^/]+$/.test(lower))
+                addArea('components', components);
+            if (/(^|\/)(navigation|routing|routes?|router)(\/|\.|$)|(^|\/)[^/]*(?:navigation|router|routes?)\.[^/]+$/.test(lower))
+                addArea('navigation', navigation);
+        }
+    };
+    await walk(root);
+    const sort = (values) => values.sort((left, right) => (left < right ? -1 : left > right ? 1 : 0));
+    return {
+        all: sort(all),
+        state: sort(state),
+        services: sort(services),
+        network: sort(network),
+        persistence: sort(persistence),
+        architecture: sort(architecture),
+        screens: sort(screens),
+        components: sort(components),
+        navigation: sort(navigation),
+        symlinks: sort(symlinks),
+        totalFiles,
+        omittedFiles: Math.max(0, totalFiles - INVENTORY_SAMPLE_LIMIT),
+        prunedDirectories: sort(prunedDirectories),
+        prunedDirectoryCount,
+        omittedPrunedDirectories: Math.max(0, prunedDirectoryCount - INVENTORY_SAMPLE_LIMIT),
+        sampleLimit: INVENTORY_SAMPLE_LIMIT,
+        areaCounts,
+        manifestCandidates: manifestCandidates.sort(),
+        manifestCandidatesOmitted,
+    };
+}
+const INVENTORY_SAMPLE_LIMIT = 1000;
+const MANIFEST_CANDIDATE_LIMIT = 512;
+function emptyAreaCounts() {
+    return {
+        state: 0,
+        services: 0,
+        network: 0,
+        persistence: 0,
+        architecture: 0,
+        screens: 0,
+        components: 0,
+        navigation: 0,
+    };
+}
+async function shouldPruneDirectory(root, relativePath) {
+    const segments = relativePath.toLowerCase().split('/');
+    const name = segments.at(-1) ?? '';
+    if (/^(node_modules|vendor|pods|\.venv|\.gradle|\.dart_tool|\.next|\.nuxt|coverage)$/.test(name))
+        return true;
+    if (!/^(dist|build|out|target|bin|obj)$/.test(name))
+        return false;
+    const parent = dirname(join(root, relativePath));
+    const names = (await readdir(parent)).map((entry) => entry.toLowerCase());
+    if (names.some((entry) => /^(package\.json|pubspec\.yaml|pom\.xml|build\.gradle(?:\.kts)?)$|\.(csproj|fsproj|vbproj)$/.test(entry)))
+        return true;
+    if (segments.slice(0, -1).some((segment) => /^(src|lib|app|packages)$/.test(segment)))
+        return false;
+    return !['bin', 'obj'].includes(name);
+}
+function isCredentialDataPath(path) {
+    const segments = path.split('/');
+    const basename = segments.at(-1) ?? '';
+    if (/(^|\/)(\.env(?:\.[^/]*)?)(\/|$)/.test(path) ||
+        /\.(pem|key|p12|pfx|jks|keystore)$/.test(path) ||
+        /(^|\/)id_(rsa|dsa|ecdsa|ed25519)$/.test(path))
+        return true;
+    const parentIsSensitive = segments
+        .slice(0, -1)
+        .some((segment) => /^(?:secret|secrets|credential|credentials)$/i.test(segment));
+    return parentIsSensitive && /\.(json|ya?ml|toml|ini|conf|cfg|txt)$/i.test(basename);
+}
+async function detectStacks(root, manifestCandidates) {
+    const detected = [];
+    for (const candidate of manifestCandidates) {
+        const directory = dirname(join(root, candidate));
+        const packageManifest = candidate.toLowerCase().endsWith('package.json')
+            ? await readJsonManifest(join(root, candidate))
+            : null;
+        const dependencies = new Set([
+            ...Object.keys(packageManifest?.dependencies ?? {}),
+            ...Object.keys(packageManifest?.devDependencies ?? {}),
+        ]);
+        const relative = directory.slice(root.length + 1).replace(/\\/g, '/') || '.';
+        const prefix = relative === '.' ? '' : `${relative}/`;
+        if (candidate.toLowerCase().endsWith('pubspec.yaml')) {
+            const pubspec = await readBoundedText(join(root, candidate));
+            if (pubspec !== null && isFlutterManifest(pubspec))
+                detected.push({ stack: 'Flutter', evidence: `${prefix}pubspec.yaml declares Flutter` });
+        }
+        if (candidate.toLowerCase().endsWith('package.json') && dependencies.has('@nestjs/core'))
+            detected.push({ stack: 'Nest', evidence: `${prefix}package.json declares @nestjs/core` });
+        if (candidate.toLowerCase().endsWith('package.json') &&
+            (dependencies.has('react') || dependencies.has('react-dom')))
+            detected.push({ stack: 'React', evidence: `${prefix}package.json declares React` });
+        if (/build\.gradle(?:\.kts)?$/i.test(candidate)) {
+            const gradle = await readBoundedText(join(root, candidate));
+            if (gradle !== null && isSpringGradleManifest(gradle))
+                detected.push({ stack: 'Spring', evidence: `${candidate} declares Spring` });
+        }
+        if (candidate.toLowerCase().endsWith('pom.xml')) {
+            const pom = await readBoundedText(join(root, candidate));
+            if (pom !== null && isSpringManifest(pom))
+                detected.push({ stack: 'Spring', evidence: `${prefix}pom.xml declares Spring` });
+        }
+    }
+    return detected;
+}
+function meaningfulEntries(entries) {
+    return entries.filter((entry) => entry.name !== '.git');
+}
+async function readBoundedText(path, maxBytes = 1024 * 1024) {
+    try {
+        const info = await lstat(path);
+        if (!info.isFile() || info.isSymbolicLink() || info.size > maxBytes)
+            return null;
+        return await readFile(path, 'utf8');
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            'code' in error &&
+            error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+async function readJsonManifest(path) {
+    const text = await readBoundedText(path);
+    if (text === null)
+        return null;
+    try {
+        const value = JSON.parse(text);
+        return value !== null && typeof value === 'object'
+            ? value
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isFlutterManifest(text) {
+    return (/(^|\n)\s*(?:flutter|flutter_test|flutter_lints)\s*:/m.test(text) ||
+        /(^|\n)\s*sdk\s*:\s*flutter\s*$/m.test(text));
+}
+function isSpringGradleManifest(text) {
+    const declarations = text.replace(/\/\*[\s\S]*?\*\/|^\s*\/\/.*$/gm, '');
+    return /\bid\s*(?:\(\s*)?["']org\.springframework\.boot["']|\bapply\s+plugin\s*:\s*["']org\.springframework\.boot["']|["']org\.springframework(?:\.boot)?:[^"'\r\n]+["']/.test(declarations);
+}
+function isSpringManifest(text) {
+    return /org\.springframework|spring-boot-(?:starter|maven-plugin)|spring-boot-starter-parent/i.test(text);
+}
+async function assertNoRepositoryAncestor(path, runner) {
+    const target = resolve(path);
+    let current = target;
+    let checkedRepository = false;
+    while (true) {
+        try {
+            const info = await lstat(current);
+            if (info.isSymbolicLink())
+                throw new Error('Project path ancestry must not contain symbolic links');
+            if (!info.isDirectory())
+                throw new Error('Project path must be a real directory');
+            if (!checkedRepository) {
+                const result = await runner.run('git', ['rev-parse', '--show-toplevel'], { cwd: current });
+                if (result.exitCode === 0 &&
+                    resolve(result.stdout.trim()) !== (await canonicalPath(target))) {
+                    throw new Error('Refusing to initialize inside an existing parent repository');
+                }
+                checkedRepository = true;
+            }
+        }
+        catch (error) {
+            if (!(error instanceof Error &&
+                'code' in error &&
+                error.code === 'ENOENT'))
+                throw error;
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            return;
+        current = parent;
+    }
+}
+//# sourceMappingURL=project-intake.js.map