@murphai/murph 0.1.15 → 0.1.17

package/node_modules/@murphai/assistant-engine/dist/usecases/integrated-services.js

@@ -0,0 +1,661 @@
+import { resolveSystemTimeZone } from "@murphai/contracts";
+import { VaultCliError } from "@murphai/operator-config/vault-cli-errors";
+import { ensureManagedDeviceSyncControlPlane, getManagedDeviceSyncDaemonStatus, startManagedDeviceSyncDaemon, stopManagedDeviceSyncDaemon, } from "@murphai/operator-config/device-daemon";
+import { createDeviceSyncClient } from "@murphai/operator-config/device-sync-client";
+import { createExplicitHealthCoreServices, createExplicitHealthQueryServices, } from "./explicit-health-family-services.js";
+import { createUnwiredMethod, loadImporterRuntime, loadIntegratedRuntime, } from "./runtime.js";
+import { asEntityEnvelope, asListEnvelope, describeLookupConstraint, materializeExportPack, matchesGenericKindFilter, normalizeIssues, toGenericListItem, toGenericShowEntity, } from "./shared.js";
+import { normalizeRepeatableEnumFlagOption, normalizeRepeatableFlagOption, } from "../option-utils.js";
+import { listDocumentRecords as listDocumentsUseCase, showDocumentManifest as showDocumentImportManifestUseCase, showDocumentRecord as showDocumentUseCase, } from "./document-meal-read.js";
+import { addSampleRecordsFromInput, eventScaffoldKindSchema, listEventRecords, listProviderRecords, scaffoldEventPayload, scaffoldProviderPayload, showEventRecord, showProviderRecord, upsertEventRecordFromInput, upsertProviderRecordFromInput, } from "./provider-event.js";
+import { addDailyFoodRecord, listFoodRecords, renameFoodRecord, scaffoldFoodPayload, showFoodRecord, upsertFoodRecordFromInput, } from "./food.js";
+import { listRecipeRecords, scaffoldRecipePayload, showRecipeRecord, upsertRecipeRecordFromInput, } from "./recipe.js";
+import { appendJournalText, checkpointExperimentRecordFromInput, listExperimentRecords, listJournalRecords, showExperimentRecord, showJournalRecord, showVaultStats as showVaultStatsUseCase, showVaultSummary as showVaultSummaryUseCase, stopExperimentRecord, updateExperimentRecordFromInput, updateVaultSummary, createExperimentRecord, ensureJournalRecord, linkJournalEventIds, linkJournalStreams, unlinkJournalEventIds, unlinkJournalStreams, } from "./experiment-journal-vault.js";
+import { toVaultCliError, toVaultUpgradeCliError, } from "./vault-usecase-helpers.js";
+function createIntegratedCoreServices() {
+    return {
+        async init(input) {
+            const { vault } = input;
+            const { core } = await loadIntegratedRuntime();
+            await core.initializeVault({
+                vaultRoot: vault,
+                timezone: input.timezone ?? resolveSystemTimeZone(),
+            });
+            return {
+                vault,
+                created: true,
+                directories: [...core.REQUIRED_DIRECTORIES],
+                files: ["vault.json", "CORE.md"],
+            };
+        },
+        async validate(input) {
+            const { vault } = input;
+            const { core } = await loadIntegratedRuntime();
+            const result = await core.validateVault({ vaultRoot: vault });
+            return {
+                vault,
+                valid: result.valid,
+                issues: normalizeIssues(result.issues),
+            };
+        },
+        async repairVault(input) {
+            const { vault } = input;
+            const { core } = await loadIntegratedRuntime();
+            const result = await core.repairVault({ vaultRoot: vault });
+            return {
+                vault,
+                metadataFile: result.metadataFile,
+                title: result.title,
+                timezone: result.timezone,
+                createdDirectories: result.createdDirectories,
+                updated: result.updated,
+                auditPath: result.auditPath,
+            };
+        },
+        async upgradeVault(input) {
+            const { vault } = input;
+            const { core } = await loadIntegratedRuntime();
+            try {
+                const result = await core.upgradeVault({
+                    vaultRoot: vault,
+                    dryRun: input.dryRun,
+                });
+                return {
+                    vault,
+                    metadataFile: result.metadataFile,
+                    title: result.title,
+                    timezone: result.timezone,
+                    fromFormatVersion: result.fromFormatVersion,
+                    toFormatVersion: result.toFormatVersion,
+                    steps: result.steps,
+                    affectedFiles: result.affectedFiles,
+                    rebuildableProjectionStores: result.rebuildableProjectionStores,
+                    updated: result.updated,
+                    dryRun: result.dryRun,
+                    auditPath: result.auditPath,
+                };
+            }
+            catch (error) {
+                throw toVaultUpgradeCliError(error);
+            }
+        },
+        async addMeal(input) {
+            const { vault, photo, audio, note, occurredAt } = input;
+            const { core } = await loadIntegratedRuntime();
+            const result = await core.addMeal({
+                vaultRoot: vault,
+                photoPath: photo,
+                audioPath: audio,
+                note,
+                occurredAt,
+            });
+            return {
+                vault,
+                mealId: result.mealId,
+                eventId: result.event.id,
+                lookupId: result.mealId,
+                occurredAt: result.event.occurredAt ?? null,
+                photoPath: result.photo?.relativePath ?? null,
+                audioPath: result.audio?.relativePath ?? null,
+                manifestFile: result.manifestPath,
+                note: result.event.note ?? note ?? null,
+            };
+        },
+        async createExperiment(input) {
+            return createExperimentRecord(input);
+        },
+        async updateExperiment(input) {
+            return updateExperimentRecordFromInput(input);
+        },
+        async checkpointExperiment(input) {
+            return checkpointExperimentRecordFromInput(input);
+        },
+        async stopExperiment(input) {
+            return stopExperimentRecord(input);
+        },
+        async ensureJournal(input) {
+            const result = await ensureJournalRecord(input);
+            return {
+                ...result,
+                date: input.date,
+            };
+        },
+        async appendJournal(input) {
+            return appendJournalText(input);
+        },
+        async linkJournalEvents(input) {
+            return linkJournalEventIds(input);
+        },
+        async unlinkJournalEvents(input) {
+            return unlinkJournalEventIds(input);
+        },
+        async linkJournalStreams(input) {
+            return linkJournalStreams(input);
+        },
+        async unlinkJournalStreams(input) {
+            return unlinkJournalStreams(input);
+        },
+        async scaffoldProvider(input) {
+            return {
+                vault: input.vault,
+                noun: "provider",
+                payload: scaffoldProviderPayload(),
+            };
+        },
+        async upsertProvider(input) {
+            return upsertProviderRecordFromInput(input);
+        },
+        async scaffoldRecipe(input) {
+            return {
+                vault: input.vault,
+                noun: 'recipe',
+                payload: scaffoldRecipePayload(),
+            };
+        },
+        async upsertRecipe(input) {
+            return upsertRecipeRecordFromInput(input);
+        },
+        async scaffoldFood(input) {
+            return {
+                vault: input.vault,
+                noun: 'food',
+                payload: scaffoldFoodPayload(),
+            };
+        },
+        async upsertFood(input) {
+            return upsertFoodRecordFromInput(input);
+        },
+        async renameFood(input) {
+            return renameFoodRecord(input);
+        },
+        async addDailyFood(input) {
+            return addDailyFoodRecord(input);
+        },
+        async scaffoldEvent(input) {
+            const kind = eventScaffoldKindSchema.parse(input.kind);
+            return {
+                vault: input.vault,
+                noun: "event",
+                kind,
+                payload: scaffoldEventPayload(kind),
+            };
+        },
+        async upsertEvent(input) {
+            return upsertEventRecordFromInput(input);
+        },
+        async addSamples(input) {
+            return addSampleRecordsFromInput(input);
+        },
+        async updateVault(input) {
+            return updateVaultSummary(input);
+        },
+        async projectAssessment(input) {
+            const { vault, assessmentId } = input;
+            const { core } = await loadIntegratedRuntime();
+            const assessment = await core.readAssessmentResponse({
+                vaultRoot: vault,
+                assessmentId,
+            });
+            const proposal = await core.projectAssessmentResponse({
+                assessmentResponse: assessment,
+            });
+            return {
+                vault,
+                assessmentId,
+                proposal,
+            };
+        },
+        ...createExplicitHealthCoreServices(async () => {
+            const { core } = await loadIntegratedRuntime();
+            return { core };
+        }),
+        async rebuildCurrentProfile(input) {
+            const { vault } = input;
+            const { core } = await loadIntegratedRuntime();
+            const result = await core.rebuildCurrentProfile({
+                vaultRoot: vault,
+            });
+            return {
+                vault,
+                profilePath: result.relativePath,
+                snapshotId: result.snapshot?.id ?? null,
+                updated: result.updated,
+            };
+        },
+    };
+}
+function createIntegratedImporterServices() {
+    return {
+        async importDocument(input) {
+            const { vault, file, title, occurredAt, note, source } = input;
+            const importers = await loadImporterRuntime();
+            const result = await importers.importDocument({
+                filePath: file,
+                vaultRoot: vault,
+                title,
+                occurredAt,
+                note,
+                source,
+            });
+            return {
+                vault,
+                sourceFile: file,
+                rawFile: result.raw.relativePath,
+                manifestFile: result.manifestPath,
+                documentId: result.documentId,
+                eventId: result.event.id,
+                lookupId: result.documentId,
+            };
+        },
+        async importSamplesCsv(input) {
+            const { vault, file, stream, tsColumn, valueColumn, unit } = input;
+            const importers = await loadImporterRuntime();
+            const result = await importers.importCsvSamples({
+                filePath: file,
+                vaultRoot: vault,
+                stream,
+                tsColumn,
+                valueColumn,
+                unit,
+            });
+            return {
+                vault,
+                sourceFile: file,
+                stream,
+                importedCount: result.count,
+                transformId: result.transformId,
+                manifestFile: result.manifestPath,
+                lookupIds: result.records.map((record) => record.id),
+                ledgerFiles: result.shardPaths,
+            };
+        },
+        async importAssessmentResponse(input) {
+            const { vault, file } = input;
+            const importers = await loadImporterRuntime();
+            const result = await importers.importAssessmentResponse({
+                filePath: file,
+                vaultRoot: vault,
+            });
+            return {
+                vault,
+                sourceFile: file,
+                rawFile: result.raw.relativePath,
+                manifestFile: result.manifestPath,
+                assessmentId: result.assessment.id,
+                lookupId: result.assessment.id,
+                ledgerFile: result.ledgerPath,
+            };
+        },
+    };
+}
+function createIntegratedQueryServices() {
+    return {
+        ...createExplicitHealthQueryServices(async () => {
+            const { query } = await loadIntegratedRuntime();
+            return { query };
+        }),
+        async showDocument(input) {
+            return showDocumentUseCase(input.vault, input.id);
+        },
+        async listDocuments(input) {
+            return listDocumentsUseCase(input);
+        },
+        async showDocumentManifest(input) {
+            return showDocumentImportManifestUseCase(input.vault, input.id);
+        },
+        async showProvider(input) {
+            return showProviderRecord(input.vault, input.lookup);
+        },
+        async listProviders(input) {
+            return listProviderRecords(input);
+        },
+        async showRecipe(input) {
+            return showRecipeRecord(input.vault, input.lookup);
+        },
+        async listRecipes(input) {
+            return listRecipeRecords(input);
+        },
+        async showFood(input) {
+            return showFoodRecord(input.vault, input.lookup);
+        },
+        async listFoods(input) {
+            return listFoodRecords(input);
+        },
+        async showEvent(input) {
+            return showEventRecord(input.vault, input.eventId);
+        },
+        async listEvents(input) {
+            return listEventRecords(input);
+        },
+        async showExperiment(input) {
+            return showExperimentRecord(input.vault, input.lookup);
+        },
+        async listExperiments(input) {
+            return listExperimentRecords(input);
+        },
+        async showJournal(input) {
+            return showJournalRecord(input.vault, input.date);
+        },
+        async listJournals(input) {
+            return listJournalRecords(input);
+        },
+        async showVault(input) {
+            return showVaultSummaryUseCase(input.vault);
+        },
+        async showVaultStats(input) {
+            return showVaultStatsUseCase(input.vault);
+        },
+        async show(input) {
+            const { vault, id } = input;
+            const constraint = describeLookupConstraint(id);
+            if (constraint) {
+                throw new VaultCliError("invalid_lookup_id", constraint, {
+                    id,
+                });
+            }
+            const { query } = await loadIntegratedRuntime();
+            const readModel = await query.readVault(vault);
+            const entity = query.lookupEntityById(readModel, id);
+            if (!entity) {
+                throw new VaultCliError("not_found", `No entity found for "${id}".`);
+            }
+            return {
+                vault,
+                entity: toGenericShowEntity(entity),
+            };
+        },
+        async list(input) {
+            const { vault, recordType, kind, status, stream, experiment, from, to, tag, limit, } = input;
+            const { query } = await loadIntegratedRuntime();
+            const recordTypes = normalizeRepeatableEnumFlagOption(recordType, "record-type", query.ALL_QUERY_ENTITY_FAMILIES) ?? [];
+            const readModel = await query.readVault(vault);
+            const streams = normalizeRepeatableFlagOption(stream, "stream") ?? [];
+            const tags = normalizeRepeatableFlagOption(tag, "tag") ?? [];
+            const items = query
+                .listEntities(readModel, {
+                families: recordTypes.length > 0 ? recordTypes : undefined,
+                statuses: status ? [status] : undefined,
+                streams: streams.length > 0 ? streams : undefined,
+                experimentSlug: experiment,
+                from,
+                tags: tags.length > 0 ? tags : undefined,
+                to,
+            })
+                .filter((entity) => matchesGenericKindFilter(entity, kind))
+                .slice(0, limit)
+                .map(toGenericListItem);
+            return asListEnvelope(vault, {
+                recordType: recordTypes,
+                kind,
+                status,
+                stream: streams,
+                experiment,
+                from,
+                to,
+                tag: tags,
+                limit,
+            }, items);
+        },
+        async showWearableDay(input) {
+            const normalized = normalizeWearableDayInput(input);
+            const { query } = await loadIntegratedRuntime();
+            const readModel = await query.readVault(input.vault);
+            const summary = query.summarizeWearableDay(readModel, normalized.date, {
+                providers: normalized.filters.providers.length > 0
+                    ? normalized.filters.providers
+                    : undefined,
+            });
+            return {
+                vault: input.vault,
+                date: normalized.date,
+                filters: normalized.filters,
+                summary,
+            };
+        },
+        async listWearableSleep(input) {
+            const normalized = normalizeWearableSummaryInput(input);
+            const { query } = await loadIntegratedRuntime();
+            const readModel = await query.readVault(input.vault);
+            const items = query.summarizeWearableSleep(readModel, normalized.queryFilters);
+            return {
+                vault: input.vault,
+                filters: normalized.filters,
+                items,
+                count: items.length,
+            };
+        },
+        async listWearableActivity(input) {
+            const normalized = normalizeWearableSummaryInput(input);
+            const { query } = await loadIntegratedRuntime();
+            const readModel = await query.readVault(input.vault);
+            const items = query.summarizeWearableActivity(readModel, normalized.queryFilters);
+            return {
+                vault: input.vault,
+                filters: normalized.filters,
+                items,
+                count: items.length,
+            };
+        },
+        async listWearableBodyState(input) {
+            const normalized = normalizeWearableSummaryInput(input);
+            const { query } = await loadIntegratedRuntime();
+            const readModel = await query.readVault(input.vault);
+            const items = query.summarizeWearableBodyState(readModel, normalized.queryFilters);
+            return {
+                vault: input.vault,
+                filters: normalized.filters,
+                items,
+                count: items.length,
+            };
+        },
+        async listWearableRecovery(input) {
+            const normalized = normalizeWearableSummaryInput(input);
+            const { query } = await loadIntegratedRuntime();
+            const readModel = await query.readVault(input.vault);
+            const items = query.summarizeWearableRecovery(readModel, normalized.queryFilters);
+            return {
+                vault: input.vault,
+                filters: normalized.filters,
+                items,
+                count: items.length,
+            };
+        },
+        async listWearableSources(input) {
+            const normalized = normalizeWearableSummaryInput(input);
+            const { query } = await loadIntegratedRuntime();
+            const readModel = await query.readVault(input.vault);
+            const items = query.summarizeWearableSourceHealth(readModel, normalized.queryFilters);
+            return {
+                vault: input.vault,
+                filters: normalized.filters,
+                items,
+                count: items.length,
+            };
+        },
+        async exportPack(input) {
+            const { vault, from, to, experiment, out } = input;
+            const { query } = await loadIntegratedRuntime();
+            const readModel = await query.readVaultTolerant(vault);
+            const pack = query.buildExportPack(readModel, {
+                from,
+                to,
+                experimentSlug: experiment,
+            });
+            await materializeExportPack(vault, pack.files);
+            if (out) {
+                await materializeExportPack(out, pack.files);
+            }
+            return {
+                vault,
+                from,
+                to,
+                experiment: experiment ?? null,
+                outDir: out ?? null,
+                packId: pack.packId,
+                files: pack.files.map((file) => file.path),
+            };
+        },
+    };
+}
+function normalizeWearableDayInput(input) {
+    const date = input.date.trim();
+    const providers = normalizeWearableProviders(input.providers);
+    return {
+        date,
+        filters: {
+            providers,
+        },
+    };
+}
+function normalizeWearableSummaryInput(input) {
+    const date = typeof input.date === 'string' && input.date.trim() ? input.date.trim() : undefined;
+    const from = date ?? input.from;
+    const to = date ?? input.to;
+    const providers = normalizeWearableProviders(input.providers);
+    const limit = normalizeWearableLimit(input.limit);
+    return {
+        filters: {
+            date: date ?? null,
+            from: from ?? null,
+            to: to ?? null,
+            providers,
+            limit,
+        },
+        queryFilters: {
+            from,
+            to,
+            providers: providers.length > 0 ? providers : undefined,
+            limit,
+        },
+    };
+}
+function normalizeWearableProviders(providers) {
+    return [...new Set((providers ?? [])
+            .map((provider) => provider.trim())
+            .filter((provider) => provider.length > 0))];
+}
+function normalizeWearableLimit(limit) {
+    if (!Number.isInteger(limit) || limit <= 0) {
+        return 30;
+    }
+    return Math.min(limit, 200);
+}
+function createIntegratedDeviceSyncServices() {
+    async function createControlPlaneClient(input) {
+        const controlPlane = await ensureManagedDeviceSyncControlPlane({
+            vault: input.vault,
+            baseUrl: input.baseUrl,
+        });
+        return createDeviceSyncClient({
+            baseUrl: controlPlane.baseUrl,
+            controlToken: controlPlane.controlToken,
+        });
+    }
+    return {
+        async listProviders(input) {
+            const client = await createControlPlaneClient(input);
+            const result = await client.listProviders();
+            return {
+                baseUrl: client.baseUrl,
+                providers: result.providers,
+            };
+        },
+        async connect(input) {
+            const client = await createControlPlaneClient(input);
+            const result = await client.beginConnection({
+                provider: input.provider,
+                returnTo: input.returnTo,
+                open: input.open,
+            });
+            return {
+                baseUrl: client.baseUrl,
+                provider: result.provider,
+                state: result.state,
+                expiresAt: result.expiresAt,
+                authorizationUrl: result.authorizationUrl,
+                openedBrowser: result.openedBrowser,
+            };
+        },
+        async listAccounts(input) {
+            const client = await createControlPlaneClient(input);
+            const result = await client.listAccounts({
+                provider: input.provider,
+            });
+            return {
+                baseUrl: client.baseUrl,
+                provider: input.provider ?? null,
+                accounts: result.accounts,
+            };
+        },
+        async showAccount(input) {
+            const client = await createControlPlaneClient(input);
+            const result = await client.showAccount(input.accountId);
+            return {
+                baseUrl: client.baseUrl,
+                account: result.account,
+            };
+        },
+        async reconcileAccount(input) {
+            const client = await createControlPlaneClient(input);
+            const result = await client.reconcileAccount(input.accountId);
+            return {
+                baseUrl: client.baseUrl,
+                account: result.account,
+                job: result.job,
+            };
+        },
+        async disconnectAccount(input) {
+            const client = await createControlPlaneClient(input);
+            const result = await client.disconnectAccount(input.accountId);
+            return {
+                baseUrl: client.baseUrl,
+                account: result.account,
+            };
+        },
+        async daemonStatus(input) {
+            return await getManagedDeviceSyncDaemonStatus({
+                vault: input.vault,
+                baseUrl: input.baseUrl,
+            });
+        },
+        async daemonStart(input) {
+            return await startManagedDeviceSyncDaemon({
+                vault: input.vault,
+                baseUrl: input.baseUrl,
+            });
+        },
+        async daemonStop(input) {
+            return await stopManagedDeviceSyncDaemon({
+                vault: input.vault,
+                baseUrl: input.baseUrl,
+            });
+        },
+    };
+}
+function createIntegratedVaultServiceGroups() {
+    return {
+        core: createIntegratedCoreServices(),
+        importers: createIntegratedImporterServices(),
+        query: createIntegratedQueryServices(),
+        devices: createIntegratedDeviceSyncServices(),
+    };
+}
+function createUnwiredServiceGroup(groupName, integratedServices) {
+    return Object.fromEntries(Object.keys(integratedServices).map((methodName) => [
+        methodName,
+        createUnwiredMethod(`${groupName}.${methodName}`),
+    ]));
+}
+export function createIntegratedVaultServices() {
+    return createIntegratedVaultServiceGroups();
+}
+export function createUnwiredVaultServices() {
+    const integratedServices = createIntegratedVaultServiceGroups();
+    return {
+        core: createUnwiredServiceGroup("core", integratedServices.core),
+        importers: createUnwiredServiceGroup("importers", integratedServices.importers),
+        query: createUnwiredServiceGroup("query", integratedServices.query),
+        devices: createUnwiredServiceGroup("devices", integratedServices.devices),
+    };
+}
+//# sourceMappingURL=integrated-services.js.map