@haaaiawd/second-nature 0.1.1 → 0.1.3

package/runtime/storage/services/quiet-input-loader.d.ts

@@ -0,0 +1,40 @@
+import type { AssetRepository } from "../repositories/asset-repository.js";
+export interface CurationInputQuery {
+    dateRange?: {
+        start: string;
+        end: string;
+    };
+    assetFilters?: {
+        includeJournal?: boolean;
+        includeReports?: boolean;
+        includeCurated?: boolean;
+    };
+}
+export interface JournalEntry {
+    id: string;
+    timestamp: string;
+    content: string;
+    category: string;
+}
+export interface ReportEntry {
+    id: string;
+    day: string;
+    summary: string;
+    highlights: string[];
+    sources: string[];
+}
+export interface CurationInputBundle {
+    journalEntries: JournalEntry[];
+    dailyReports: ReportEntry[];
+    sourceCount: number;
+}
+export declare class QuietInputLoader {
+    private readonly assetRepository;
+    constructor(assetRepository: AssetRepository);
+    loadQuietInputs(query: CurationInputQuery): Promise<CurationInputBundle>;
+    private loadJournalEntries;
+    private loadSingleDayJournal;
+    private loadReportEntries;
+    private loadSingleDayReport;
+}
+export declare function createQuietInputLoader(assetRepository: AssetRepository): QuietInputLoader;

package/runtime/storage/services/quiet-input-loader.js

@@ -0,0 +1,131 @@
+import { resolveDailyJournalPath, resolveDailyReportPath, readText } from "../memory/workspace/paths.js";
+export class QuietInputLoader {
+    assetRepository;
+    constructor(assetRepository) {
+        this.assetRepository = assetRepository;
+    }
+    async loadQuietInputs(query) {
+        const filters = query.assetFilters ?? {
+            includeJournal: true,
+            includeReports: true,
+            includeCurated: false,
+        };
+        const journalEntries = [];
+        const dailyReports = [];
+        if (filters.includeJournal) {
+            const journalEntriesResult = await this.loadJournalEntries(query.dateRange);
+            journalEntries.push(...journalEntriesResult);
+        }
+        if (filters.includeReports) {
+            const reportEntriesResult = await this.loadReportEntries(query.dateRange);
+            dailyReports.push(...reportEntriesResult);
+        }
+        return {
+            journalEntries,
+            dailyReports,
+            sourceCount: journalEntries.length + dailyReports.length,
+        };
+    }
+    async loadJournalEntries(dateRange) {
+        if (!dateRange) {
+            const today = new Date().toISOString().split("T")[0];
+            return this.loadSingleDayJournal(today);
+        }
+        const entries = [];
+        const startDate = new Date(dateRange.start);
+        const endDate = new Date(dateRange.end);
+        const current = new Date(startDate);
+        while (current <= endDate) {
+            const day = current.toISOString().split("T")[0];
+            const dayEntries = await this.loadSingleDayJournal(day);
+            entries.push(...dayEntries);
+            current.setDate(current.getDate() + 1);
+        }
+        return entries;
+    }
+    async loadSingleDayJournal(day) {
+        const journalPath = resolveDailyJournalPath(day);
+        const content = await readText(journalPath);
+        if (!content) {
+            return [];
+        }
+        const entries = [];
+        const lines = content.split("\n").filter((line) => line.trim().startsWith("- ["));
+        for (const line of lines) {
+            const match = line.match(/- \[(\d{4}-\d{2}-\d{2}T[\d:]+)\] (.+)/);
+            if (match) {
+                const [, timestamp, rest] = match;
+                const categoryMatch = rest.match(/^\[(.*?)\]\s*(.*)/);
+                const category = categoryMatch ? categoryMatch[1] : "unknown";
+                const content = categoryMatch ? categoryMatch[2] : rest;
+                entries.push({
+                    id: `journal:${day}:${entries.length}`,
+                    timestamp,
+                    content,
+                    category,
+                });
+            }
+        }
+        return entries;
+    }
+    async loadReportEntries(dateRange) {
+        if (!dateRange) {
+            const today = new Date().toISOString().split("T")[0];
+            const report = await this.loadSingleDayReport(today);
+            return report ? [report] : [];
+        }
+        const entries = [];
+        const startDate = new Date(dateRange.start);
+        const endDate = new Date(dateRange.end);
+        const current = new Date(startDate);
+        while (current <= endDate) {
+            const day = current.toISOString().split("T")[0];
+            const dayEntry = await this.loadSingleDayReport(day);
+            if (dayEntry) {
+                entries.push(dayEntry);
+            }
+            current.setDate(current.getDate() + 1);
+        }
+        return entries;
+    }
+    async loadSingleDayReport(day) {
+        const reportPath = resolveDailyReportPath(day);
+        const content = await readText(reportPath);
+        if (!content) {
+            return null;
+        }
+        const summaryMatch = content.match(/## Summary\n([\s\S]*?)(?=##|$)/);
+        const highlightsMatch = content.match(/## Highlights\n([\s\S]*?)(?=##|$)/);
+        const sourcesMatch = content.match(/## Sources\n([\s\S]*?)$/);
+        const summary = summaryMatch ? summaryMatch[1].trim() : "";
+        const highlights = [];
+        if (highlightsMatch) {
+            const highlightLines = highlightsMatch[1].split("\n").filter((l) => l.trim().startsWith("-"));
+            for (const h of highlightLines) {
+                highlights.push(h.replace(/^-\s*/, "").trim());
+            }
+        }
+        const sources = [];
+        if (sourcesMatch) {
+            const sourceLines = sourcesMatch[1].split("\n").filter((l) => l.trim());
+            for (const s of sourceLines) {
+                const match = s.match(/- Activities: (.*)/);
+                const obsMatch = s.match(/- Observations: (.*)/);
+                if (match)
+                    sources.push(...match[1].split(", "));
+                else if (obsMatch)
+                    sources.push(...obsMatch[1].split(", "));
+            }
+        }
+        return {
+            id: `report:${day}`,
+            day,
+            summary,
+            highlights,
+            sources,
+        };
+    }
+}
+export function createQuietInputLoader(assetRepository) {
+    return new QuietInputLoader(assetRepository);
+}

package/runtime/storage/services/repair-and-backup.d.ts

@@ -0,0 +1,22 @@
+import type { StateDatabase } from "../db/index.js";
+export interface RepairAndBackupOptions {
+    now?: Date;
+    staleProposalDays?: number;
+    backupDir?: string;
+}
+export interface RepairAndBackupResult {
+    scannedAssetCount: number;
+    repairedOrphanIndexCount: number;
+    updatedHashCount: number;
+    staleProposalCount: number;
+    backupPath: string;
+    repairedOrphanAssetIds: string[];
+    updatedHashAssetIds: string[];
+    staleProposalIds: string[];
+}
+export declare class RepairAndBackupService {
+    private readonly database;
+    constructor(database: StateDatabase);
+    runStartupRepair(options?: RepairAndBackupOptions): Promise<RepairAndBackupResult>;
+}
+export declare function createRepairAndBackupService(database: StateDatabase): RepairAndBackupService;

package/runtime/storage/services/repair-and-backup.js

@@ -0,0 +1,73 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { and, eq, inArray, lt } from "drizzle-orm";
+import { assetRegistry, proposalRecords } from "../db/schema/index.js";
+import { fileExists, hashFile } from "../memory/workspace/paths.js";
+const DEFAULT_STALE_DAYS = 7;
+const DEFAULT_BACKUP_DIR = "./workspace/backups";
+export class RepairAndBackupService {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    async runStartupRepair(options = {}) {
+        const now = options.now ?? new Date();
+        const staleProposalDays = options.staleProposalDays ?? DEFAULT_STALE_DAYS;
+        const backupDir = options.backupDir ?? DEFAULT_BACKUP_DIR;
+        const assets = await this.database.db.select().from(assetRegistry);
+        const repairedOrphanAssetIds = [];
+        const updatedHashAssetIds = [];
+        for (const asset of assets) {
+            const exists = await fileExists(asset.path);
+            if (!exists) {
+                repairedOrphanAssetIds.push(asset.id);
+                continue;
+            }
+            const currentHash = await hashFile(asset.path);
+            if (currentHash && currentHash !== asset.hash) {
+                updatedHashAssetIds.push(asset.id);
+                await this.database.db
+                    .update(assetRegistry)
+                    .set({
+                    hash: currentHash,
+                    lastIndexedAt: now.toISOString(),
+                })
+                    .where(eq(assetRegistry.id, asset.id));
+            }
+        }
+        if (repairedOrphanAssetIds.length > 0) {
+            await this.database.db
+                .delete(assetRegistry)
+                .where(inArray(assetRegistry.id, repairedOrphanAssetIds));
+        }
+        const staleCutoff = new Date(now.getTime() - staleProposalDays * 24 * 60 * 60 * 1000).toISOString();
+        const staleProposals = await this.database.db
+            .select({ id: proposalRecords.id })
+            .from(proposalRecords)
+            .where(and(inArray(proposalRecords.status, ["draft", "requires_review"]), lt(proposalRecords.createdAt, staleCutoff)));
+        const staleProposalIds = staleProposals.map((item) => item.id);
+        if (staleProposalIds.length > 0) {
+            await this.database.db
+                .update(proposalRecords)
+                .set({ status: "rejected" })
+                .where(inArray(proposalRecords.id, staleProposalIds));
+        }
+        await fs.mkdir(backupDir, { recursive: true });
+        const backupFileName = `state-${now.toISOString().replace(/[:.]/g, "-")}.db`;
+        const backupPath = path.join(backupDir, backupFileName);
+        await this.database.sqlite.backup(backupPath);
+        return {
+            scannedAssetCount: assets.length,
+            repairedOrphanIndexCount: repairedOrphanAssetIds.length,
+            updatedHashCount: updatedHashAssetIds.length,
+            staleProposalCount: staleProposalIds.length,
+            backupPath,
+            repairedOrphanAssetIds,
+            updatedHashAssetIds,
+            staleProposalIds,
+        };
+    }
+}
+export function createRepairAndBackupService(database) {
+    return new RepairAndBackupService(database);
+}

package/runtime/storage/state-api.d.ts

@@ -0,0 +1,46 @@
+import type { StateDatabase } from "./db/index.js";
+import type { NewPolicyRecord, PolicyRecord } from "./db/schema/index.js";
+import { type ActivityLogWrite, type ObservationWrite, type DailyReportInput, type CuratedMemoryWrite, type AssetWriteAck } from "./services/daily-log-pipeline.js";
+import { type CurationInputQuery, type CurationInputBundle } from "./services/quiet-input-loader.js";
+import type { PersonaCandidate, SceneContext } from "../guidance/types.js";
+type PolicyState = Omit<NewPolicyRecord, "updatedAt">;
+export interface MemoryReadPort {
+    loadQuietInputs(query: CurationInputQuery): Promise<CurationInputBundle>;
+    loadPolicy(platformId: string): Promise<PolicyRecord | undefined>;
+    loadPersonaCandidates(sceneContext: SceneContext): Promise<PersonaCandidate[]>;
+}
+export interface MemoryWritePort {
+    appendActivityLog(entry: ActivityLogWrite): Promise<AssetWriteAck>;
+    appendObservation(entry: ObservationWrite): Promise<AssetWriteAck>;
+    generateDailyReport(input: DailyReportInput): Promise<AssetWriteAck>;
+    upsertCuratedMemory(item: CuratedMemoryWrite): Promise<AssetWriteAck>;
+    savePolicy(input: PolicyState): Promise<void>;
+}
+export interface CredentialContextPort {
+    loadCredentialContext(platformId: string): Promise<unknown>;
+    saveCredentialContext(input: unknown): Promise<void>;
+}
+export interface IntentCommitPort {
+    loadIntentCommitRecord(intentId: string): Promise<unknown>;
+}
+export interface ProvenancePort {
+    explainProvenance(assetId: string): Promise<unknown>;
+}
+export interface StateAPI {
+    readonly read: MemoryReadPort;
+    readonly write: MemoryWritePort;
+    readonly credentials: CredentialContextPort;
+    readonly commits: IntentCommitPort;
+    readonly provenance: ProvenancePort;
+}
+export declare class DefaultStateAPI implements StateAPI {
+    private readonly database;
+    readonly read: MemoryReadPort;
+    readonly write: MemoryWritePort;
+    readonly credentials: CredentialContextPort;
+    readonly commits: IntentCommitPort;
+    readonly provenance: ProvenancePort;
+    constructor(database: StateDatabase);
+}
+export declare function createStateAPI(database: StateDatabase): StateAPI;
+export {};

package/runtime/storage/state-api.js

@@ -0,0 +1,73 @@
+import { AssetRepository } from "./repositories/asset-repository.js";
+import { CredentialRepository } from "./repositories/credential-repository.js";
+import { ProposalRepository } from "./repositories/proposal-repository.js";
+import { ProvenanceRepository } from "./repositories/provenance-repository.js";
+import { IntentCommitRepository } from "./repositories/intent-commit-repository.js";
+import { PolicyRepository } from "./repositories/policy-repository.js";
+import { createDailyLogPipeline, } from "./services/daily-log-pipeline.js";
+import { createQuietInputLoader, } from "./services/quiet-input-loader.js";
+import { createPersonaCandidateLoader } from "./services/persona-candidate-loader.js";
+export class DefaultStateAPI {
+    database;
+    read;
+    write;
+    credentials;
+    commits;
+    provenance;
+    constructor(database) {
+        this.database = database;
+        const assetRepository = new AssetRepository(database);
+        const credentialRepository = new CredentialRepository(database);
+        const proposalRepository = new ProposalRepository(database);
+        const provenanceRepository = new ProvenanceRepository(database);
+        const intentCommitRepository = new IntentCommitRepository(database);
+        const policyRepository = new PolicyRepository(database);
+        const dailyLogPipeline = createDailyLogPipeline(assetRepository, provenanceRepository);
+        const quietInputLoader = createQuietInputLoader(assetRepository);
+        const personaCandidateLoader = createPersonaCandidateLoader();
+        this.read = {
+            loadQuietInputs: (query) => quietInputLoader.loadQuietInputs(query),
+            loadPolicy: (platformId) => policyRepository.findByPlatformId(platformId),
+            loadPersonaCandidates: (sceneContext) => personaCandidateLoader.loadPersonaCandidates(sceneContext),
+        };
+        this.write = {
+            appendActivityLog: (entry) => dailyLogPipeline.appendActivityLog(entry),
+            appendObservation: (entry) => dailyLogPipeline.appendObservation(entry),
+            generateDailyReport: (input) => dailyLogPipeline.generateDailyReport(input),
+            upsertCuratedMemory: (item) => dailyLogPipeline.upsertCuratedMemory(item),
+            savePolicy: async (policy) => {
+                await policyRepository.upsert({
+                    platformId: policy.platformId,
+                    socialDailyLimit: policy.socialDailyLimit,
+                    quietEnabled: policy.quietEnabled,
+                    updatedAt: new Date().toISOString(),
+                });
+            },
+        };
+        this.credentials = {
+            loadCredentialContext: async (platformId) => {
+                return credentialRepository.findByPlatformId(platformId);
+            },
+            saveCredentialContext: async (input) => {
+                const ctx = input;
+                await credentialRepository.upsert({
+                    ...ctx,
+                    updatedAt: ctx.updatedAt ?? new Date().toISOString(),
+                });
+            },
+        };
+        this.commits = {
+            loadIntentCommitRecord: async (intentId) => {
+                return intentCommitRepository.findByIntentId(intentId);
+            },
+        };
+        this.provenance = {
+            explainProvenance: async (assetId) => {
+                return provenanceRepository.traceAsset(assetId);
+            },
+        };
+    }
+}
+export function createStateAPI(database) {
+    return new DefaultStateAPI(database);
+}