salmon-loop 0.2.3

package/dist/core/sub-agent/controller.js

@@ -0,0 +1,69 @@
+const LOG_HISTORY_LIMIT = 50;
+export class InMemorySubAgentController {
+    agents = new Map();
+    registerAgent(id, profile, status) {
+        const existing = this.agents.get(id);
+        if (existing) {
+            existing.status = status;
+            existing.updatedAt = new Date();
+            return;
+        }
+        this.agents.set(id, {
+            id,
+            profile,
+            status,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            stopRequested: false,
+            logs: [],
+        });
+    }
+    updateStatus(id, status, summary) {
+        const agent = this.agents.get(id);
+        if (!agent)
+            return;
+        agent.status = status;
+        agent.updatedAt = new Date();
+        if (summary)
+            agent.summary = summary;
+        this.appendLog(id, `Status -> ${status}${summary ? ` (${summary})` : ''}`);
+    }
+    appendLog(id, message) {
+        const agent = this.agents.get(id);
+        if (!agent)
+            return;
+        agent.logs.push(`${new Date().toISOString()} ${message}`);
+        if (agent.logs.length > LOG_HISTORY_LIMIT) {
+            agent.logs.splice(0, agent.logs.length - LOG_HISTORY_LIMIT);
+        }
+    }
+    listAgents() {
+        return Array.from(this.agents.values());
+    }
+    getAgent(id) {
+        return this.agents.get(id);
+    }
+    tailLogs(id, count) {
+        const agent = this.agents.get(id);
+        if (!agent)
+            return [];
+        return agent.logs.slice(-count);
+    }
+    requestStop(id) {
+        const agent = this.agents.get(id);
+        if (!agent)
+            return false;
+        if (agent.stopRequested)
+            return true;
+        agent.stopRequested = true;
+        this.appendLog(id, 'Stop requested via CLI');
+        return true;
+    }
+    isStopRequested(id) {
+        return this.agents.get(id)?.stopRequested ?? false;
+    }
+}
+export function createSubAgentController() {
+    return new InMemorySubAgentController();
+}
+//# sourceMappingURL=controller.js.map

package/dist/core/sub-agent/core/loop.js

@@ -0,0 +1,79 @@
+import { text } from '../../../locales/index.js';
+import { Pipeline } from '../../grizzco/engine/pipeline/pipeline.js';
+import { saveAudit } from '../../grizzco/steps/audit.js';
+import { buildContext } from '../../grizzco/steps/context.js';
+import { generatePatch } from '../../grizzco/steps/patch.js';
+import { generatePlan } from '../../grizzco/steps/plan.js';
+import { runPreflight } from '../../grizzco/steps/preflight.js';
+import { getLogger } from '../../observability/logger.js';
+/**
+ * SmallfryLoop (The "Little Fry" in the loop)
+ * A specialized execution flow for sub-agents.
+ *
+ * This loop is intentionally proposal-only:
+ * - It may generate plans and patches.
+ * - It MUST NOT mutate the user's workspace (no APPLY, no VERIFY).
+ *
+ * Mutation remains the responsibility of the primary salmonloop (s8p) runtime.
+ */
+export class SmallfryLoop {
+    profile;
+    constructor(profile) {
+        this.profile = profile;
+    }
+    /**
+     * Run the recursive loop based on the stratagem.
+     */
+    async execute(initCtx) {
+        getLogger().info(`[SmallfryLoop] ${text.smallfry.status.working} (${this.profile.name})`);
+        let pipeline = Pipeline.of(initCtx);
+        // Dynamic Phase Injection based on Stratagem
+        pipeline = pipeline.step('PREFLIGHT', runPreflight);
+        pipeline = pipeline.step('CONTEXT', buildContext);
+        pipeline = pipeline.step('PLAN', generatePlan);
+        if (this.profile.stratagem === 'surgeon') {
+            pipeline = pipeline.step('PATCH', generatePatch);
+        }
+        const report = await pipeline.execute();
+        report.auditPath = await saveAudit(report, initCtx.options);
+        const finalCtx = report.data;
+        // 4. Audit & Resource Tracking (Physical Traceability)
+        // We sum up actual token usage from traces if available, otherwise fallback to estimation
+        let totalInputTokens = 0;
+        let totalOutputTokens = 0;
+        for (const trace of report.traces) {
+            const usage = trace.metadata?.usage;
+            if (usage) {
+                totalInputTokens += usage.prompt_tokens || 0;
+                totalOutputTokens += usage.completion_tokens || 0;
+            }
+        }
+        const tokenUsage = totalInputTokens + totalOutputTokens;
+        // Hard Budget Enforcement Check
+        if (this.profile.maxTokens && tokenUsage > this.profile.maxTokens) {
+            getLogger().warn(`[SmallfryLoop] Budget exceeded: ${tokenUsage}/${this.profile.maxTokens}`);
+            report.success = false;
+            if (finalCtx) {
+                finalCtx.reason = text.smallfry.errors.budgetExceeded(tokenUsage, this.profile.maxTokens);
+            }
+        }
+        return {
+            agent_ref: this.profile.id,
+            success: report.success,
+            summary: report.success
+                ? text.smallfry.status.submitting
+                : finalCtx?.reason || report.error?.message || text.smallfry.errors.missionFailed,
+            tokenUsage,
+            auditPath: report.auditPath,
+            reason: finalCtx?.reason || report.error?.message || '',
+            reasonCode: finalCtx?.reasonCode || (report.success ? 'SUCCESS' : 'LOOP_FAILED'),
+            attempts: finalCtx?.attempt || 1,
+            logs: finalCtx?.logs || [],
+            failurePhase: report.lastStep,
+            errorType: finalCtx?.errorType,
+            finalPatch: typeof finalCtx?.diff === 'string' ? finalCtx.diff : undefined,
+            changedFiles: Array.isArray(finalCtx?.changedFiles) ? finalCtx.changedFiles : [],
+        };
+    }
+}
+//# sourceMappingURL=loop.js.map

package/dist/core/sub-agent/core/manager.js

@@ -0,0 +1,246 @@
+import { createHash, randomBytes } from 'crypto';
+import { text } from '../../../locales/index.js';
+import { createFileSystemAdapter } from '../../adapters/fs/index.js';
+import * as fs from '../../adapters/fs/node-fs.js';
+import { GitAdapter } from '../../adapters/git/git-adapter.js';
+import { getLogger } from '../../observability/logger.js';
+import { FileStateResolver } from '../../strata/layers/file-state-resolver.js';
+import { RuntimeEnvironment } from '../../strata/runtime/environment.js';
+import { ErrorType } from '../../types/index.js';
+import { ArtifactStore } from '../artifacts/store.js';
+import { getSubAgentRegistry } from '../registry.js';
+import { SmallfryLoop } from './loop.js';
+/**
+ * SubAgentManager coordinates the lifecycle of Smallfrys.
+ * It handles profile resolution, budget monitoring, and result aggregation.
+ */
+export class SubAgentManager {
+    ctx;
+    controller;
+    activeAgents = new Map();
+    deps;
+    constructor(ctx, controller, deps) {
+        this.ctx = ctx;
+        this.controller = controller;
+        this.deps = {
+            registry: deps?.registry ?? getSubAgentRegistry(),
+            createRuntimeEnvironment: deps?.createRuntimeEnvironment ??
+                ((options, emit) => new RuntimeEnvironment(options, emit)),
+            artifactStore: deps?.artifactStore ?? ArtifactStore,
+        };
+    }
+    /**
+     * Spawns a new sub-agent and monitors its execution.
+     */
+    async execute(request) {
+        const profile = this.deps.registry.get(request.agent_ref);
+        if (!profile) {
+            return this.fail(request.agent_ref, text.smallfry.errors.profileNotFound(request.agent_ref), 'LOOP_FAILED');
+        }
+        const agentId = `smallfry-${randomBytes(4).toString('hex')}`;
+        const currentDepth = request.recursionDepth || 0;
+        const MAX_RECURSION_DEPTH = 2;
+        if (currentDepth >= MAX_RECURSION_DEPTH) {
+            const msg = text.smallfry.errors.recursionLimitExceeded(currentDepth, MAX_RECURSION_DEPTH);
+            getLogger().error(`[SubAgentManager] ${msg}`);
+            return this.fail(profile.id, msg, 'LOOP_FAILED');
+        }
+        this.activeAgents.set(agentId, { profile, status: 'hiring' });
+        this.controller.registerAgent(agentId, profile, 'hiring');
+        getLogger().info(`[SubAgentManager] ${text.smallfry.status.spawning} (ID: ${agentId}, Role: ${profile.role})`);
+        const llm = this.ctx.llm;
+        if (!llm) {
+            const msg = text.smallfry.errors.dispatchMissingRuntimeLlm;
+            getLogger().error(`[SubAgentManager] ${msg}`);
+            return this.fail(profile.id, msg, 'LOOP_CRASH');
+        }
+        try {
+            this.updateStatus(agentId, 'working');
+            if (this.controller.isStopRequested(agentId)) {
+                throw new Error('Stop requested before launching Smallfry');
+            }
+            const runtimeEnv = await this.setupIsolatedEnvironment(request, llm, agentId);
+            try {
+                const workspace = runtimeEnv.workspace;
+                const activePath = workspace.workPath;
+                const git = new GitAdapter(activePath);
+                const resolver = new FileStateResolver(git, activePath);
+                const flowMode = 'patch';
+                const fsAdapter = createFileSystemAdapter(flowMode);
+                // 2. Construct InitCtx for the smallfry
+                const initCtx = {
+                    workspace: {
+                        workPath: activePath,
+                        baseRepoPath: workspace.baseRepoPath,
+                        strategy: workspace.strategy,
+                    },
+                    options: {
+                        instruction: request.task,
+                        repoPath: activePath,
+                        dryRun: this.ctx.dryRun,
+                        contextFiles: request.contextFiles || [],
+                        llm,
+                        recursionDepth: currentDepth + 1, // Increment depth for child
+                        allowedToolNames: this.filterAllowedTools(profile.allowedTools),
+                        timeoutMs: request.timeout_seconds ? request.timeout_seconds * 1000 : profile.timeoutMs,
+                    },
+                    mode: flowMode,
+                    fs: fsAdapter,
+                    emit: (event) => {
+                        // Bridge status to parent/UI
+                        if (event.type === 'phase.start') {
+                            this.updateStatus(agentId, 'working');
+                        }
+                        if (event.type === 'log') {
+                            getLogger().debug(`[Smallfry:${agentId}] ${event.level}: ${event.message}`);
+                        }
+                        else {
+                            getLogger().debug(`[Smallfry:${agentId}] ${event.type}`);
+                        }
+                    },
+                    fileStateResolver: resolver,
+                    shadowInitialRef: runtimeEnv?.initialSnapshotHash || 'HEAD',
+                };
+                // 3. Launch the "Little Fry"
+                const subLoop = new SmallfryLoop(profile);
+                const result = await subLoop.execute(initCtx);
+                return await this.persistArtifacts(agentId, result);
+            }
+            finally {
+                await runtimeEnv.teardown();
+            }
+        }
+        catch (error) {
+            this.controller.appendLog(agentId, `Execution failed: ${(error instanceof Error ? error.message : undefined) ?? error}`);
+            getLogger().error(`[SubAgentManager] Smallfry ${agentId} crashed: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                agent_ref: profile.id,
+                success: false,
+                summary: text.smallfry.errors.missionFailedWithReason(error instanceof Error ? error.message : String(error)),
+                tokenUsage: 0,
+                reason: error instanceof Error ? error.message : String(error),
+                reasonCode: 'LOOP_CRASH',
+                attempts: 1,
+                logs: [],
+                errorType: ErrorType.UNKNOWN,
+            };
+        }
+        finally {
+            this.activeAgents.delete(agentId);
+        }
+    }
+    // Backward compatibility for internal calls
+    async spawn(request) {
+        return this.execute(request);
+    }
+    updateStatus(id, status) {
+        const entry = this.activeAgents.get(id);
+        if (entry) {
+            entry.status = status;
+            getLogger().debug(`[SubAgentManager] Smallfry ${id} status: ${status}`);
+            this.controller.updateStatus(id, status);
+        }
+    }
+    fail(agentRef, reason, reasonCode) {
+        return {
+            agent_ref: agentRef,
+            success: false,
+            summary: reason,
+            tokenUsage: 0,
+            reason,
+            reasonCode,
+            attempts: 1,
+            logs: [],
+            errorType: ErrorType.UNKNOWN,
+        };
+    }
+    async setupIsolatedEnvironment(request, llm, agentId) {
+        const baseRepoPath = this.ctx.persistenceRoot || this.ctx.repoRoot;
+        const options = {
+            instruction: request.task,
+            repoPath: baseRepoPath,
+            llm,
+            dryRun: this.ctx.dryRun,
+            verify: undefined,
+            strategy: 'worktree',
+            contextFiles: request.contextFiles,
+            agentKind: 'subagent',
+        };
+        const env = this.deps.createRuntimeEnvironment(options, (event) => {
+            if (event.type === 'log') {
+                getLogger().debug(`[Smallfry:${agentId}] ${event.level}: ${event.message}`);
+            }
+        });
+        try {
+            await env.setup();
+            return env;
+        }
+        catch (error) {
+            try {
+                await env.teardown();
+            }
+            catch (teardownError) {
+                getLogger().warn(`[SubAgentManager] Failed to teardown isolated environment after setup error: ${teardownError instanceof Error ? teardownError.message : String(teardownError)}`);
+            }
+            throw error;
+        }
+    }
+    async persistArtifacts(agentId, result) {
+        const patch = result.finalPatch;
+        if (!patch || typeof patch !== 'string')
+            return result;
+        const saved = await this.deps.artifactStore.saveText({
+            content: patch,
+            mimeType: 'text/x-diff',
+            fileExt: 'patch',
+        });
+        const { finalPatch: _ignored, ...rest } = result;
+        const auditArtifact = await this.persistAuditArtifact(rest.auditPath);
+        return {
+            ...rest,
+            auditPath: auditArtifact?.handle ?? rest.auditPath,
+            auditArtifact: auditArtifact ?? undefined,
+            patchArtifact: saved,
+        };
+    }
+    filterAllowedTools(allowed) {
+        const safeReadOnlyTools = new Set([
+            'agent_dispatch',
+            'code.search',
+            'code.ast',
+            'fs.read',
+            'git.status',
+            'git.cat',
+            'artifact.read',
+        ]);
+        return allowed.filter((name) => safeReadOnlyTools.has(name));
+    }
+    async persistAuditArtifact(auditPath) {
+        if (!auditPath || typeof auditPath !== 'string')
+            return undefined;
+        if (auditPath.startsWith('s8p://artifact/')) {
+            const read = await ArtifactStore.readText(auditPath);
+            if (!read.ok)
+                return undefined;
+            const sha256 = createHash('sha256').update(read.content, 'utf8').digest('hex');
+            return {
+                handle: auditPath,
+                mimeType: 'application/json',
+                sha256,
+                size: read.size,
+            };
+        }
+        try {
+            const content = await fs.readFile(auditPath, 'utf8');
+            return await ArtifactStore.saveText({
+                content,
+                mimeType: 'application/json',
+                fileExt: 'json',
+            });
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+//# sourceMappingURL=manager.js.map

package/dist/core/sub-agent/registry-defaults.js

@@ -0,0 +1,52 @@
+const DEFAULT_SUB_AGENT_PROFILES = [
+    {
+        id: 'explorer',
+        name: 'Scout Smallfry',
+        role: 'Explorer',
+        description: 'Specializes in navigating the codebase and finding relevant context.',
+        allowedTools: ['code.search', 'fs.read', 'git.status', 'git.cat', 'code.ast'],
+        readOnly: true,
+        stratagem: 'investigator',
+        maxTokens: 50000,
+        maxAttempts: 3,
+    },
+    {
+        id: 'surgeon',
+        name: 'Smallfry Developer',
+        role: 'Coder',
+        description: 'Capable of making targeted code changes and verifying them.',
+        allowedTools: ['code.search', 'fs.read', 'test.run', 'code.ast'],
+        readOnly: false,
+        stratagem: 'surgeon',
+        maxTokens: 100000,
+        maxAttempts: 5,
+    },
+    {
+        id: 'reviewer',
+        name: 'Reviewer Smallfry',
+        role: 'Auditor',
+        description: 'Specializes in code audit and security reviews. No mutation allowed.',
+        allowedTools: ['code.search', 'fs.read', 'code.ast'],
+        readOnly: true,
+        stratagem: 'investigator',
+        maxTokens: 30000,
+        maxAttempts: 2,
+    },
+    {
+        id: 'cleaner',
+        name: 'Cleaner Smallfry',
+        role: 'Maintainer',
+        description: 'Focused on fixing linting, formatting, and minor cleanup.',
+        allowedTools: ['fs.read', 'test.run', 'code.search'],
+        readOnly: false,
+        stratagem: 'surgeon',
+        maxTokens: 50000,
+        maxAttempts: 3,
+    },
+];
+export function registerDefaultSubAgentProfiles(registry) {
+    for (const profile of DEFAULT_SUB_AGENT_PROFILES) {
+        registry.register(profile);
+    }
+}
+//# sourceMappingURL=registry-defaults.js.map

package/dist/core/sub-agent/registry.js

@@ -0,0 +1,35 @@
+export class SubAgentRegistry {
+    profiles = new Map();
+    register(profile) {
+        this.profiles.set(profile.id, profile);
+    }
+    get(id) {
+        return this.profiles.get(id);
+    }
+    getAll() {
+        return Array.from(this.profiles.values());
+    }
+    clear() {
+        this.profiles.clear();
+    }
+}
+export function createSubAgentRegistry() {
+    return new SubAgentRegistry();
+}
+let activeSubAgentRegistry = null;
+export function setSubAgentRegistry(registry) {
+    activeSubAgentRegistry = registry;
+}
+export function getSubAgentRegistry() {
+    if (!activeSubAgentRegistry) {
+        throw new Error('SubAgentRegistry is not initialized. Call setSubAgentRegistry() at startup.');
+    }
+    return activeSubAgentRegistry;
+}
+export function tryGetSubAgentRegistry() {
+    return activeSubAgentRegistry;
+}
+export function clearSubAgentRegistry() {
+    activeSubAgentRegistry = null;
+}
+//# sourceMappingURL=registry.js.map

package/dist/core/sub-agent/tools/task-spawn.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { text } from '../../../locales/index.js';
+import { createSubAgentController } from '../controller.js';
+import { SubAgentManager } from '../core/manager.js';
+import { SubAgentRequestSchema } from '../types.js';
+/**
+ * agent_dispatch (Internal: Smallfry Dispatcher)
+ * The primary tool for spawning autonomous sub-agents to handle specialized sub-tasks.
+ */
+export const subAgentTaskSpec = {
+    name: 'agent_dispatch',
+    source: 'builtin',
+    intent: 'AGENT',
+    description: text.smallfry.ui.spawnToolDescription,
+    riskLevel: 'medium',
+    // This tool is proposal-only: it may read the repo and produce structured proposals,
+    // but it MUST NOT mutate the user's workspace from within the calling phase.
+    sideEffects: ['none', 'fs_read', 'git_read'],
+    concurrency: 'parallel_ok', // Smallfrys handle their own isolation
+    allowedPhases: ['PLAN', 'CONTEXT'],
+    inputSchema: SubAgentRequestSchema,
+    outputSchema: z.any(), // Maps to SubAgentResult
+    executor: async (input, ctx) => {
+        const manager = new SubAgentManager(ctx, ctx.subAgentController ?? createSubAgentController());
+        // Launch the Smallfry via the manager
+        return await manager.execute(input);
+    },
+};
+//# sourceMappingURL=task-spawn.js.map

package/dist/core/sub-agent/types.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+/**
+ * Zod Schema for validation
+ */
+export const SubAgentRequestSchema = z.object({
+    agent_ref: z
+        .string()
+        .describe('The specialized agent role to dispatch (e.g., explorer, surgeon)'),
+    task: z.string().describe('The specific task or instruction for the sub-agent'),
+    contextFiles: z.array(z.string()).optional(),
+    recursionDepth: z.number().optional().default(0),
+    session_target: z
+        .enum(['isolated', 'shared'])
+        .default('isolated')
+        .describe('Whether the session should be isolated (shadow worktree) or shared'),
+    timeout_seconds: z.number().optional().describe('Maximum execution time in seconds'),
+    budgetOverride: z
+        .object({
+        maxTokens: z.number().optional(),
+    })
+        .optional(),
+});
+//# sourceMappingURL=types.js.map

package/dist/core/target-runtime/command-resolver.js

@@ -0,0 +1,42 @@
+function quoteShellArg(arg) {
+    if (/^[a-zA-Z0-9_./:-]+$/.test(arg))
+        return arg;
+    return JSON.stringify(arg);
+}
+export function formatShellCommand(command, args) {
+    return [quoteShellArg(command), ...args.map(quoteShellArg)].join(' ');
+}
+export function resolveScriptCommand(profile, scriptName) {
+    if (!profile.scripts[scriptName])
+        return undefined;
+    const command = profile.packageManager;
+    const args = ['run', scriptName];
+    return {
+        packageManager: profile.packageManager,
+        scriptName,
+        command,
+        args,
+        shellCommand: formatShellCommand(command, args),
+    };
+}
+export function resolveNodeVerifyCommand(profile) {
+    return resolveScriptCommand(profile, 'test')?.shellCommand;
+}
+export function resolveNodeWorktreePrepareCommand(profile) {
+    const hasLockfile = profile.source === 'lockfile';
+    switch (profile.packageManager) {
+        case 'bun':
+            return hasLockfile ? 'bun install --frozen-lockfile' : 'bun install';
+        case 'pnpm':
+            return hasLockfile ? 'pnpm install --frozen-lockfile' : 'pnpm install';
+        case 'yarn':
+            return hasLockfile ? 'yarn install --immutable' : 'yarn install';
+        case 'npm':
+            return hasLockfile ? 'npm ci' : 'npm install';
+        default: {
+            const manager = profile.packageManager;
+            return manager;
+        }
+    }
+}
+//# sourceMappingURL=command-resolver.js.map

package/dist/core/target-runtime/index.js

@@ -0,0 +1,3 @@
+export * from './profile.js';
+export * from './command-resolver.js';
+//# sourceMappingURL=index.js.map

package/dist/core/target-runtime/profile.js

@@ -0,0 +1,73 @@
+import { existsSync } from '../adapters/fs/node-fs.js';
+import { readFile } from '../adapters/fs/node-fs.js';
+import { ensureInSandbox, safeJoin } from '../utils/path.js';
+const LOCKFILE_HINTS = [
+    { file: 'bun.lock', manager: 'bun' },
+    { file: 'bun.lockb', manager: 'bun' },
+    { file: 'pnpm-lock.yaml', manager: 'pnpm' },
+    { file: 'yarn.lock', manager: 'yarn' },
+    { file: 'package-lock.json', manager: 'npm' },
+    { file: 'npm-shrinkwrap.json', manager: 'npm' },
+];
+function safeRepoPath(repoPath, relativePath) {
+    const joined = safeJoin(repoPath, relativePath);
+    return ensureInSandbox(repoPath, joined);
+}
+function parsePackageManagerField(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (!normalized)
+        return undefined;
+    const [name] = normalized.split('@');
+    if (name === 'bun' || name === 'npm' || name === 'pnpm' || name === 'yarn') {
+        return name;
+    }
+    return undefined;
+}
+function normalizeScripts(rawScripts) {
+    if (!rawScripts || typeof rawScripts !== 'object')
+        return {};
+    const scripts = {};
+    for (const [name, command] of Object.entries(rawScripts)) {
+        if (typeof command !== 'string')
+            continue;
+        const normalized = command.trim();
+        if (!normalized)
+            continue;
+        scripts[name] = normalized;
+    }
+    return scripts;
+}
+function detectPackageManager(repoPath, pkg) {
+    const packageManagerFromField = parsePackageManagerField(pkg.packageManager);
+    if (packageManagerFromField) {
+        return { packageManager: packageManagerFromField, source: 'packageManager' };
+    }
+    for (const hint of LOCKFILE_HINTS) {
+        if (existsSync(safeRepoPath(repoPath, hint.file))) {
+            return { packageManager: hint.manager, source: 'lockfile' };
+        }
+    }
+    return { packageManager: 'npm', source: 'default' };
+}
+export async function detectNodeRuntimeProfile(repoPath) {
+    const packageJsonPath = safeRepoPath(repoPath, 'package.json');
+    if (!existsSync(packageJsonPath))
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(await readFile(packageJsonPath, 'utf-8'));
+    }
+    catch {
+        return undefined;
+    }
+    const { packageManager, source } = detectPackageManager(repoPath, parsed);
+    const scripts = normalizeScripts(parsed.scripts);
+    return {
+        packageManager,
+        source,
+        scripts,
+    };
+}
+//# sourceMappingURL=profile.js.map

package/dist/core/testgen/detector.js

@@ -0,0 +1,17 @@
+import { join } from 'path';
+import { existsSync } from '../adapters/fs/node-fs.js';
+export function detectProjectType(repoPath) {
+    if (existsSync(join(repoPath, 'pom.xml')))
+        return 'java_maven';
+    if (existsSync(join(repoPath, 'build.gradle')))
+        return 'java_gradle';
+    if (existsSync(join(repoPath, 'requirements.txt')) ||
+        existsSync(join(repoPath, 'pyproject.toml')))
+        return 'python';
+    if (existsSync(join(repoPath, 'go.mod')))
+        return 'go';
+    if (existsSync(join(repoPath, 'package.json')))
+        return 'nodejs';
+    return 'unknown';
+}
+//# sourceMappingURL=detector.js.map