salmon-loop 0.2.3

package/dist/core/grizzco/execution/Executor.js

@@ -0,0 +1,58 @@
+import * as path from 'path';
+import { text } from '../../../locales/index.js';
+import { AtomicFileWriter } from '../../adapters/fs/index.js';
+import { getLogger } from '../../observability/logger.js';
+import { RejectionManager } from './RejectionManager.js';
+export class Executor {
+    workerFactory;
+    writer = new AtomicFileWriter();
+    rejectionMgr;
+    constructor(workerFactory, rejectDir = '.salmonloop/runtime/rejections') {
+        this.workerFactory = workerFactory;
+        this.rejectionMgr = new RejectionManager(rejectDir);
+    }
+    async execute(plan, ctx) {
+        const { file, operation } = ctx;
+        // 1. Handle Abort
+        if (plan.shouldAbort) {
+            await this.rejectionMgr.create(file.path, plan.abortReason || text.grizzco.errors.aborted, ctx);
+            return { success: false, error: plan.abortReason, actionTaken: 'ABORT' };
+        }
+        // 2. Select Worker
+        if (!plan.workerId) {
+            return {
+                success: false,
+                error: text.grizzco.errors.noWorkerSelected,
+                actionTaken: 'ERROR',
+            };
+        }
+        try {
+            const worker = this.workerFactory.get(plan.workerId);
+            getLogger().debug(`[Executor] Executing worker ${plan.workerId} for ${file.path}`);
+            // 3. Execute Worker
+            const result = await worker.execute(operation, file, {
+                snapshotId: ctx.snapshot.id,
+                repoRoot: ctx.repoRoot,
+            });
+            if (!result.success) {
+                await this.rejectionMgr.create(file.path, result.error || text.grizzco.errors.mergeFailed('unknown'), ctx);
+                return { success: false, error: result.error, actionTaken: 'WORKER_FAILURE' };
+            }
+            // 4. Atomic Write
+            if (result.mergedContent && !ctx.options.dryRun) {
+                const absolutePath = ctx.repoRoot ? path.join(ctx.repoRoot, file.path) : file.path;
+                await this.writer.writeAtomic(absolutePath, result.mergedContent);
+            }
+            else if (result.mergedContent && ctx.options.dryRun) {
+                getLogger().info(`[DryRun] Would write ${file.path}`);
+            }
+            return { success: true, actionTaken: `MERGE(${plan.workerId})` };
+        }
+        catch (error) {
+            const msg = text.grizzco.errors.unexpectedException(error instanceof Error ? error.message : String(error));
+            await this.rejectionMgr.create(file.path, msg, ctx);
+            return { success: false, error: msg, actionTaken: 'EXCEPTION' };
+        }
+    }
+}
+//# sourceMappingURL=Executor.js.map

package/dist/core/grizzco/execution/RejectionManager.js

@@ -0,0 +1,71 @@
+import * as path from 'path';
+import * as fs from '../../adapters/fs/node-fs.js';
+/**
+ * RejectionManager
+ * Handles creation and management of .rej files for failed merges.
+ */
+export class RejectionManager {
+    rejectDir;
+    constructor(rejectDir) {
+        this.rejectDir = rejectDir;
+    }
+    /**
+     * Create a rejection file.
+     */
+    async create(filePath, reason, context) {
+        // Sanitize path for filename
+        const safeName = filePath.replace(/[/\\]/g, '_');
+        const rejPath = path.join(this.rejectDir, `${safeName}.rej`);
+        const header = JSON.stringify({
+            reason,
+            timestamp: Date.now(),
+            fileStatus: context.file.status,
+            operationType: context.operation.type,
+        });
+        const content = context.operation.content ? context.operation.content.toString('utf-8') : '';
+        const fileBody = `${header}\n\n${content}`;
+        await fs.mkdir(this.rejectDir, { recursive: true });
+        await fs.writeFile(rejPath, fileBody, 'utf-8');
+    }
+    /**
+     * List all rejections.
+     */
+    async list() {
+        try {
+            const files = await fs.readdir(this.rejectDir);
+            const rejections = [];
+            for (const file of files) {
+                if (!file.endsWith('.rej'))
+                    continue;
+                try {
+                    const content = await fs.readFile(path.join(this.rejectDir, file), 'utf-8');
+                    const headerPart = content.split('\n\n')[0];
+                    const header = JSON.parse(headerPart);
+                    rejections.push({
+                        filePath: file.replace('.rej', '').replace(/_/g, '/'), // Approximate restoration
+                        ...header,
+                    });
+                }
+                catch {
+                    // Ignore malformed files
+                }
+            }
+            return rejections;
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Clear rejection directory
+     */
+    async clear() {
+        try {
+            await fs.rm(this.rejectDir, { recursive: true, force: true });
+        }
+        catch {
+            // Ignore
+        }
+    }
+}
+//# sourceMappingURL=RejectionManager.js.map

package/dist/core/grizzco/execution/WorkerFactory.js

@@ -0,0 +1,31 @@
+import { text } from '../../../locales/index.js';
+import { GitAdapter } from '../../adapters/git/git-adapter.js';
+import { DirectWriteWorker } from '../workers/direct-write-worker.js';
+import { GitApplyWorker } from '../workers/git-apply-worker.js';
+import { MMThreeWayWorker } from '../workers/mm-three-way-worker.js';
+import { OverwriteBinaryWorker } from '../workers/overwrite-binary-worker.js';
+import { ThreeWayMergeWorker } from '../workers/three-way-merge-worker.js';
+import { UnionMergeWorker } from '../workers/union-merge-worker.js';
+export class WorkerFactory {
+    workers = new Map();
+    constructor(repoPath) {
+        const git = new GitAdapter(repoPath);
+        this.register('direct-write', new DirectWriteWorker());
+        this.register('git-apply', new GitApplyWorker(repoPath));
+        this.register('3way-standard', new ThreeWayMergeWorker(git));
+        this.register('union-merge-safe', new UnionMergeWorker());
+        this.register('3way-mm-advanced', new MMThreeWayWorker(git));
+        this.register('overwrite-binary', new OverwriteBinaryWorker());
+    }
+    register(id, worker) {
+        this.workers.set(id, worker);
+    }
+    get(id) {
+        const worker = this.workers.get(id);
+        if (!worker) {
+            throw new Error(text.grizzco.errors.workerNotFound(id));
+        }
+        return worker;
+    }
+}
+//# sourceMappingURL=WorkerFactory.js.map

package/dist/core/grizzco/flows/SalmonLoopFlow.js

@@ -0,0 +1,102 @@
+import { Pipeline } from '../engine/pipeline/pipeline.js';
+import { generateAnswer } from '../steps/answer.js';
+import { runApplyBack } from '../steps/apply-back.js';
+import { runApply } from '../steps/apply.js';
+import { validateAst } from '../steps/ast-validate.js';
+import { saveAudit } from '../steps/audit.js';
+import { buildContext } from '../steps/context.js';
+import { displayAnswer } from '../steps/display-answer.js';
+import { displayResearch } from '../steps/display-research.js';
+import { displayReview } from '../steps/displayReview.js';
+import { exploreCodebase } from '../steps/explore.js';
+import { extractIssues } from '../steps/extractIssues.js';
+import { generateFixPlan } from '../steps/generateFixPlan.js';
+import { generateReview } from '../steps/generateReview.js';
+import { generatePatch } from '../steps/patch.js';
+import { generatePlan } from '../steps/plan.js';
+import { runPreflight } from '../steps/preflight.js';
+import { runPrepareDeps } from '../steps/prepare-deps.js';
+import { runReadOnlyShrink } from '../steps/read-only-shrink.js';
+import { generateResearch } from '../steps/research.js';
+import { runRollback, runEmergencyRollback } from '../steps/rollback.js';
+import { runShrink } from '../steps/shrink.js';
+import { validatePatch } from '../steps/validate.js';
+import { runVerify } from '../steps/verify.js';
+function buildBasePipeline(initCtx) {
+    return Pipeline.of(initCtx)
+        .step('PREFLIGHT', runPreflight)
+        .step('PREPARE_DEPS', runPrepareDeps)
+        .step('CONTEXT', buildContext)
+        .step('EXPLORE', exploreCodebase);
+}
+function buildLightAnswerPipeline(initCtx) {
+    return Pipeline.of(initCtx)
+        .step('PREFLIGHT', runPreflight)
+        .step('ANSWER', generateAnswer)
+        .step('REPORT', displayAnswer)
+        .step('SHRINK', runReadOnlyShrink);
+}
+function buildPatchPipeline(base) {
+    return base
+        .step('PLAN', generatePlan)
+        .step('PATCH', generatePatch)
+        .step('VALIDATE', validatePatch)
+        .step('AST_VALIDATE', validateAst)
+        .stepWithRecovery('APPLY', runApply, runEmergencyRollback)
+        .step('VERIFY', runVerify)
+        .step('ROLLBACK', runRollback)
+        .step('SHRINK', runShrink)
+        .step('APPLY_BACK', runApplyBack);
+}
+function buildReviewPipeline(base) {
+    return base
+        .step('REVIEW', generateReview)
+        .step('REPORT', displayReview)
+        .step('SHRINK', runReadOnlyShrink);
+}
+function buildResearchPipeline(base) {
+    return base
+        .step('RESEARCH', generateResearch)
+        .step('REPORT', displayResearch)
+        .step('SHRINK', runReadOnlyShrink);
+}
+function buildDebugPipeline(base) {
+    return base
+        .step('REVIEW', generateReview)
+        .step('ANALYZE_ISSUES', extractIssues)
+        .step('PLAN', generateFixPlan)
+        .step('PATCH', generatePatch)
+        .step('VALIDATE', validatePatch)
+        .step('AST_VALIDATE', validateAst)
+        .stepWithRecovery('APPLY', runApply, runEmergencyRollback)
+        .step('VERIFY', runVerify)
+        .step('ROLLBACK', runRollback)
+        .step('SHRINK', runShrink)
+        .step('APPLY_BACK', runApplyBack);
+}
+function buildPipelineByMode(initCtx) {
+    if (initCtx.mode === 'answer') {
+        return buildLightAnswerPipeline(initCtx);
+    }
+    const basePipeline = buildBasePipeline(initCtx);
+    if (initCtx.mode === 'review') {
+        return buildReviewPipeline(basePipeline);
+    }
+    if (initCtx.mode === 'research') {
+        return buildResearchPipeline(basePipeline);
+    }
+    if (initCtx.mode === 'debug') {
+        return buildDebugPipeline(basePipeline);
+    }
+    return buildPatchPipeline(basePipeline);
+}
+export async function executeSalmonLoopFlow(initCtx) {
+    const pipeline = buildPipelineByMode(initCtx);
+    const report = await pipeline.execute();
+    // Save audit log
+    report.auditPath = await saveAudit(report, initCtx.options);
+    report.strategyName = initCtx.mode;
+    report.fsMode = initCtx.mode;
+    return report;
+}
+//# sourceMappingURL=SalmonLoopFlow.js.map

package/dist/core/grizzco/runtime/apply-back-runtime.js

@@ -0,0 +1,136 @@
+import { text } from '../../../locales/index.js';
+import { recordAuditEvent } from '../../observability/audit-trail.js';
+import { writeDebugArtifact } from '../../observability/debug-artifacts.js';
+import { buildErrorEnvelope, toSafeErrorSummary } from '../../observability/error-envelope.js';
+import { collectSidecarPaths } from './apply-back-utils.js';
+export async function runApplyBackPhase(params) {
+    const { checkpointRef, initialSnapshotHash, options, synchronizer, activeRepoPath, shadowTaskId, attempt, emit, } = params;
+    const applyBackTelemetry = {};
+    const nowIso = () => new Date().toISOString();
+    let failureStage = 'unknown';
+    const toSafeTelemetry = (telemetry) => ({
+        startedAt: telemetry.startedAt,
+        finishedAt: telemetry.finishedAt,
+        policy: telemetry.policy,
+        usedShadowRefs: telemetry.usedShadowRefs,
+        selectedStrategy: telemetry.selectedStrategy,
+        dirtyAtEntry: telemetry.dirtyAtEntry,
+        dirtyBackupCreated: telemetry.dirtyBackupCreated,
+        didBeginApply: telemetry.didBeginApply,
+        appliedToMain: telemetry.appliedToMain,
+        workspaceChangedAfterFailure: telemetry.workspaceChangedAfterFailure,
+        rollbackPath: telemetry.rollbackPath,
+        stagedRestoreAttempted: telemetry.stagedRestoreAttempted,
+        stagedRestoreSucceeded: telemetry.stagedRestoreSucceeded,
+    });
+    if (!checkpointRef || options.strategy !== 'worktree') {
+        recordAuditEvent('apply_back.skipped', { attempt, strategy: options.strategy ?? 'direct' }, { phase: 'APPLY_BACK', severity: 'low', scope: 'session' });
+        return { success: true, skipped: true, telemetry: applyBackTelemetry };
+    }
+    recordAuditEvent('apply_back.start', {
+        attempt,
+        strategy: options.strategy ?? 'worktree',
+        changedFiles: params.changedFiles.length,
+    }, { phase: 'APPLY_BACK', severity: 'low', scope: 'session' });
+    emit?.({
+        type: 'log',
+        level: 'info',
+        message: text.loop.applyBackStarted(attempt),
+        timestamp: new Date(),
+    });
+    try {
+        failureStage = 'checkpointCommit';
+        const finalRef = (await synchronizer.createCheckpointCommit(activeRepoPath, shadowTaskId, `final-${attempt}`)) || checkpointRef.baseRef;
+        failureStage = 'applyBackToMain';
+        await synchronizer.applyBackToMainWorkspace(options.repoPath, checkpointRef, params.diff || '', options.applyBackOnDirty ?? '3way', options.verbose, params.changedFiles, initialSnapshotHash, finalRef, collectSidecarPaths(options), applyBackTelemetry);
+        recordAuditEvent('apply_back.success', {
+            attempt,
+            changedFiles: params.changedFiles.length,
+            telemetry: applyBackTelemetry,
+        }, { phase: 'APPLY_BACK', severity: 'low', scope: 'session' });
+        emit?.({
+            type: 'log',
+            level: 'info',
+            message: text.loop.applyBackSucceeded(attempt),
+            timestamp: new Date(),
+        });
+        return { success: true, skipped: false, telemetry: applyBackTelemetry };
+    }
+    catch (error) {
+        const errorCode = 'APPLY_BACK_FAILED';
+        const safeMeta = {
+            stage: failureStage,
+            attempt,
+            changedFiles: params.changedFiles.length,
+            strategy: options.strategy ?? 'direct',
+            applyBackOnDirty: options.applyBackOnDirty ?? '3way',
+            errorSummary: toSafeErrorSummary(error),
+            timestamp: nowIso(),
+        };
+        const safeMessage = failureStage === 'checkpointCommit'
+            ? text.loop.applyBackFailedPrepare
+            : failureStage === 'applyBackToMain'
+                ? text.loop.applyBackFailedSync
+                : text.loop.applyBackFailed;
+        let debugArtifact = null;
+        try {
+            debugArtifact = await writeDebugArtifact({
+                repoRoot: options.repoPath,
+                auditScope: options.auditScope,
+                prefix: 'apply-back-error',
+                content: [
+                    `applyBack failure`,
+                    `attempt=${attempt}`,
+                    `stage=${failureStage}`,
+                    `changedFiles=${params.changedFiles.length}`,
+                    `strategy=${options.strategy ?? 'direct'}`,
+                    `applyBackOnDirty=${options.applyBackOnDirty ?? '3way'}`,
+                    '',
+                    `safeTelemetry=${JSON.stringify(toSafeTelemetry(applyBackTelemetry), null, 2)}`,
+                    '',
+                    `errorType=${error instanceof Error ? error.name : typeof error}`,
+                    `errorCode=${error?.code ?? error?.llmCode ?? ''}`,
+                    `errorMessage=${error instanceof Error ? error.message : String(error)}`,
+                ].join('\n'),
+            });
+        }
+        catch {
+            // Best-effort: do not mask the primary failure if artifact writing fails.
+        }
+        const envelope = buildErrorEnvelope({
+            domain: 'applyBack',
+            code: errorCode,
+            phase: 'APPLY_BACK',
+            safeMessage,
+            safeMeta,
+            debugArtifact: debugArtifact ?? undefined,
+        });
+        recordAuditEvent('apply_back.failure', {
+            attempt,
+            changedFiles: params.changedFiles.length,
+            telemetry: toSafeTelemetry(applyBackTelemetry),
+            errorCode,
+            safeMessage,
+            safeMeta,
+            debugArtifact: debugArtifact ?? undefined,
+        }, { phase: 'APPLY_BACK', severity: 'high', scope: 'session' });
+        emit?.({
+            type: 'log',
+            level: 'error',
+            message: envelope.safeMessage,
+            code: envelope.code,
+            timestamp: new Date(),
+        });
+        return {
+            success: false,
+            skipped: false,
+            telemetry: applyBackTelemetry,
+            error: envelope.safeMessage,
+            errorCode: envelope.code,
+            safeMessage: envelope.safeMessage,
+            safeMeta: envelope.safeMeta,
+            debugArtifact: envelope.debugArtifact,
+        };
+    }
+}
+//# sourceMappingURL=apply-back-runtime.js.map

package/dist/core/grizzco/runtime/apply-back-utils.js

@@ -0,0 +1,13 @@
+export function collectSidecarPaths(options) {
+    if (!options.contextFiles || options.contextFiles.length === 0) {
+        return [];
+    }
+    const paths = new Set();
+    for (const filePath of options.contextFiles) {
+        if (filePath) {
+            paths.add(filePath);
+        }
+    }
+    return Array.from(paths);
+}
+//# sourceMappingURL=apply-back-utils.js.map

package/dist/core/grizzco/runtime/host/host-runner.js

@@ -0,0 +1,99 @@
+import { createFileSystemAdapter } from '../../../adapters/fs/index.js';
+import { sanitizeError } from '../../../llm/errors.js';
+import { recordAuditEvent } from '../../../observability/audit-trail.js';
+import { initPlan } from '../../../plan/index.js';
+import { RuntimeEnvironment } from '../../../strata/runtime/environment.js';
+export class HostRunner {
+    options;
+    emit;
+    now;
+    env;
+    planRuntime;
+    flowMode;
+    fsAdapter;
+    static runtimeEnvironmentCtor = RuntimeEnvironment;
+    constructor(options, emit, now) {
+        this.options = options;
+        this.emit = emit;
+        this.now = now;
+        this.flowMode = options.mode ?? 'patch';
+        this.fsAdapter = options.fileSystemOverride
+            ? createFileSystemAdapter(this.flowMode, options.fileSystemOverride)
+            : createFileSystemAdapter(this.flowMode);
+    }
+    async boot() {
+        this.env = new HostRunner.runtimeEnvironmentCtor(this.options, this.emit);
+        await this.env.setup();
+        const activeRepoPath = this.env.activeRepoPath;
+        this.emit({
+            type: 'workspace.ready',
+            path: activeRepoPath,
+            strategy: this.options.strategy || 'local',
+            timestamp: this.now(),
+        });
+        await this.initializePlanRuntime(activeRepoPath);
+        return {
+            env: this.env,
+            flowMode: this.flowMode,
+            fsAdapter: this.fsAdapter,
+            activeRepoPath,
+            planRuntime: this.planRuntime,
+        };
+    }
+    async teardown() {
+        if (!this.env)
+            return;
+        try {
+            await this.env.teardown();
+        }
+        finally {
+            this.env = undefined;
+        }
+    }
+    async initializePlanRuntime(activeRepoPath) {
+        try {
+            const initialized = await initPlan({
+                persistenceRoot: this.env.workspace.baseRepoPath || activeRepoPath,
+                mission: this.options.instruction,
+                objective: 'Track task progress and support resumable execution.',
+                context: `mode=${this.flowMode}\nverify=${this.options.verify}\nstrategy=${this.options.strategy ?? 'local'}`,
+            });
+            this.planRuntime = {
+                sessionId: initialized.sessionId,
+                planPathHint: initialized.planPathHint,
+            };
+            recordAuditEvent('plan.runtime.init', {
+                sessionId: initialized.sessionId,
+                planPathHint: initialized.planPathHint,
+            }, { source: 'plan', severity: 'low', scope: 'session', phase: 'PREFLIGHT' });
+            this.emit({
+                type: 'plan.runtime.ready',
+                sessionId: initialized.sessionId,
+                planPathHint: initialized.planPathHint,
+                timestamp: this.now(),
+            });
+            this.emit({
+                type: 'log',
+                level: 'debug',
+                message: `Runtime plan initialized: sessionId=${initialized.sessionId}`,
+                timestamp: this.now(),
+            });
+        }
+        catch (error) {
+            const reason = sanitizeError(error);
+            this.emit({
+                type: 'plan.runtime.unavailable',
+                reason,
+                timestamp: this.now(),
+            });
+            recordAuditEvent('plan.runtime.init.failed', { error: reason }, { source: 'plan', severity: 'medium', scope: 'session', phase: 'PREFLIGHT' });
+            this.emit({
+                type: 'log',
+                level: 'warn',
+                message: `Runtime plan init failed (continuing without plan): ${reason}`,
+                timestamp: this.now(),
+            });
+        }
+    }
+}
+//# sourceMappingURL=host-runner.js.map

package/dist/core/grizzco/runtime/host/index.js

@@ -0,0 +1,2 @@
+export { HostRunner } from './host-runner.js';
+//# sourceMappingURL=index.js.map

package/dist/core/grizzco/runtime/host/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/grizzco/services/CachedService.js

@@ -0,0 +1,42 @@
+import { getLogger } from '../../observability/logger.js';
+/**
+ * Caching Decorator for IDataService.
+ * Supports path-aware caching to handle both global (e.g. Git Config)
+ * and file-specific (e.g. Remote Locks) data requirements.
+ */
+export class CachedService {
+    delegate;
+    cache = new Map();
+    inFlight = new Map();
+    constructor(delegate) {
+        this.delegate = delegate;
+    }
+    get id() {
+        return this.delegate.id;
+    }
+    async fetch(ctx, filePath) {
+        // Composite key: workspace + filePath (if provided)
+        const scope = ctx.workspace?.workPath || 'global';
+        const key = filePath ? `${scope}:${filePath}` : scope;
+        if (this.cache.has(key)) {
+            return this.cache.get(key);
+        }
+        const pending = this.inFlight.get(key);
+        if (pending) {
+            return pending;
+        }
+        getLogger().debug(`[CachedService] Cache miss for ${this.id} (Scope: ${key}), fetching...`);
+        const request = this.delegate
+            .fetch(ctx, filePath)
+            .then((result) => {
+            this.cache.set(key, result);
+            return result;
+        })
+            .finally(() => {
+            this.inFlight.delete(key);
+        });
+        this.inFlight.set(key, request);
+        return request;
+    }
+}
+//# sourceMappingURL=CachedService.js.map

package/dist/core/grizzco/services/implementations/default/GitConfigService.js

@@ -0,0 +1,38 @@
+import { GitAdapter } from '../../../../adapters/git/git-adapter.js';
+import { getLogger } from '../../../../observability/logger.js';
+export class GitConfigService {
+    id = 'git_config';
+    async fetch(ctx, _filePath) {
+        getLogger().debug('[GitConfigService] Fetching git configuration...');
+        try {
+            const git = new GitAdapter(ctx.workspace.workPath);
+            const getConfig = async (key) => {
+                try {
+                    return await git.exec(['config', '--get', key], { allowError: true });
+                }
+                catch {
+                    return null;
+                }
+            };
+            const [userName, userEmail, remoteOrigin] = await Promise.all([
+                getConfig('user.name'),
+                getConfig('user.email'),
+                getConfig('remote.origin.url'),
+            ]);
+            return {
+                user: {
+                    name: userName || null,
+                    email: userEmail || null,
+                },
+                remote: {
+                    origin: remoteOrigin || null,
+                },
+            };
+        }
+        catch (error) {
+            getLogger().warn(`[GitConfigService] Failed to fetch config: ${error}`);
+            return { user: {}, remote: {} };
+        }
+    }
+}
+//# sourceMappingURL=GitConfigService.js.map

package/dist/core/grizzco/services/implementations/mock/MockLockService.js

@@ -0,0 +1,11 @@
+import { getLogger } from '../../../../observability/logger.js';
+export class MockLockService {
+    id = 'remote_lock';
+    async fetch(_ctx, filePath) {
+        getLogger().debug(`[MockLockService] Checking remote lock status for ${filePath || 'unknown file'}...`);
+        // Simulate async fetch
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        return { isLocked: false, owner: null };
+    }
+}
+//# sourceMappingURL=MockLockService.js.map

package/dist/core/grizzco/services/implementations/mock/MockUserQuotaService.js

@@ -0,0 +1,11 @@
+import { getLogger } from '../../../../observability/logger.js';
+export class MockUserQuotaService {
+    id = 'user_quota';
+    async fetch(_ctx, _filePath) {
+        getLogger().debug('[MockUserQuotaService] Checking user quota...');
+        // Simulate async fetch
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        return { remaining: 1000 };
+    }
+}
+//# sourceMappingURL=MockUserQuotaService.js.map

package/dist/core/grizzco/services/registry.js

@@ -0,0 +1,30 @@
+import { getLogger } from '../../observability/logger.js';
+/**
+ * Service Registry for Bifrost Architecture
+ * Manages the lifecycle and discovery of asynchronous data services.
+ */
+const services = new Map();
+export const registry = {
+    /**
+     * Register a data service provider
+     */
+    register(service) {
+        if (services.has(service.id)) {
+            getLogger().warn(`[ServiceRegistry] Overwriting existing service: ${service.id}`);
+        }
+        services.set(service.id, service);
+    },
+    /**
+     * Get a service instance by its identifier
+     */
+    get(id) {
+        return services.get(id);
+    },
+    /**
+     * Check if a specific service is registered
+     */
+    has(id) {
+        return services.has(id);
+    },
+};
+//# sourceMappingURL=registry.js.map

package/dist/core/grizzco/services/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map