om-memory-system 3.0.0 → 3.1.0-next.3

package/dist/core/profile-analysis.d.ts

@@ -0,0 +1,16 @@
+import type { UserProfileData } from "../services/user-profile/types.js";
+export interface ModelPort {
+    provider: string;
+    modelId: string;
+    complete(systemPrompt: string, userPrompt: string): Promise<string>;
+}
+export interface ExistingProfileInput {
+    id: string;
+    profileData: string;
+}
+export interface ProfileAnalysisResult {
+    raw: UserProfileData;
+    merged: UserProfileData | null;
+}
+/** Analyse prompts with a host-neutral model and merge the validated profile. */
+export declare function analyzeProfile(model: ModelPort, context: string, existingProfile: ExistingProfileInput | null, timeoutMs?: number): Promise<ProfileAnalysisResult>;

package/dist/core/profile-analysis.js

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { createUserProfileAnalysisSchema, extractJsonObject } from "./extraction.js";
+import { log } from "../services/logger.js";
+function buildProfileAnalysisSystemPrompt(existingProfile) {
+    return `You are a user behavior analyst for a coding assistant.
+
+Your task is to analyze user prompts and ${existingProfile ? "update" : "create"} a comprehensive user profile.
+
+CRITICAL: Detect the language used by the user in their prompts. You MUST output all descriptions, categories, and text in the SAME language as the user's prompts.
+
+CRITICAL: All JSON string values MUST escape double quotes with backslash. Do NOT use unescaped quotation marks inside string values.
+
+Respond with a single JSON object matching the update_user_profile contract.`;
+}
+/** Analyse prompts with a host-neutral model and merge the validated profile. */
+export async function analyzeProfile(model, context, existingProfile, timeoutMs = 120000) {
+    let timeoutId;
+    try {
+        const reply = await Promise.race([
+            model.complete(buildProfileAnalysisSystemPrompt(Boolean(existingProfile)), context),
+            new Promise((_, reject) => {
+                timeoutId = setTimeout(() => reject(new Error("pi profile analysis: timeout")), timeoutMs);
+                timeoutId?.unref?.();
+            }),
+        ]);
+        const schema = createUserProfileAnalysisSchema(z);
+        const parsed = schema.safeParse(extractJsonObject(reply));
+        if (!parsed.success) {
+            log("pi profile analysis: model reply failed shared schema validation", {
+                provider: model.provider,
+                modelId: model.modelId,
+            });
+            throw new Error("pi profile analysis: invalid profile payload");
+        }
+        const raw = parsed.data;
+        if (!existingProfile)
+            return { raw, merged: null };
+        const { userProfileManager } = await import("../services/user-profile/user-profile-manager.js");
+        const existingData = JSON.parse(existingProfile.profileData);
+        const merged = await userProfileManager.mergeProfileData(existingData, raw, undefined, existingProfile.id);
+        return { raw, merged };
+    }
+    finally {
+        if (timeoutId)
+            clearTimeout(timeoutId);
+    }
+}

package/dist/importer/import-args.d.ts

@@ -0,0 +1,44 @@
+import type { ImportPathMap } from "./importer.js";
+/**
+ * One option grammar for every history-import surface: the Pi and OpenCode
+ * slash commands and the `om-memory-system` CLI. Hosts differ only in where
+ * their history lives (`--root` for Pi, `--db` for OpenCode) and in how a
+ * model is chosen (a session uses its host's sign-in; the CLI uses an
+ * external API and key).
+ */
+export type ImportHost = "pi" | "opencode";
+export type ImportSurface = "session" | "cli";
+export interface HistoryImportArgs {
+    help: boolean;
+    dryRun: boolean;
+    force: boolean;
+    skipMemories: boolean;
+    skipProfile: boolean;
+    profileBatch?: number;
+    /** Session: `provider/id` from the host's signed-in models. CLI: a model id for `--provider`. */
+    model?: string;
+    scope: "current-project" | "all-projects";
+    /** Project directory for `current-project` scope; defaults to the working directory. */
+    project?: string;
+    session?: string;
+    since?: number;
+    until?: number;
+    maxSessions?: number;
+    pathMaps: ImportPathMap[];
+    /** History location: Pi session root (`--root`) or OpenCode database (`--db`). */
+    source?: string;
+    provider?: string;
+    apiUrl?: string;
+    apiKeyEnv?: string;
+    errors: string[];
+}
+export declare const SOURCE_FLAG: Record<ImportHost, string>;
+/** Split a slash-command argument string, honouring single and double quotes. */
+export declare function tokenizeImportArgs(raw: string): string[];
+export declare function parseHistoryImportArgs(tokens: string[], options: {
+    host: ImportHost;
+    surface: ImportSurface;
+}): HistoryImportArgs;
+/** True when the run calls a model: a real import of memories or the profile. */
+export declare function importNeedsModel(args: HistoryImportArgs): boolean;
+export declare function historyImportUsage(host: ImportHost, surface: ImportSurface): string;

package/dist/importer/import-args.js

@@ -0,0 +1,219 @@
+export const SOURCE_FLAG = { pi: "--root", opencode: "--db" };
+const CLI_ONLY_FLAGS = new Set(["--provider", "--api-url", "--api-key-env"]);
+const BOOLEAN_FLAGS = new Set([
+    "--help",
+    "-h",
+    "--dry-run",
+    "--force",
+    "--skip-memories",
+    "--skip-profile",
+]);
+const VALUE_FLAGS = new Set([
+    "--profile-batch",
+    "--model",
+    "--scope",
+    "--project",
+    "--session",
+    "--since",
+    "--until",
+    "--max-sessions",
+    "--map",
+    "--root",
+    "--db",
+    ...CLI_ONLY_FLAGS,
+]);
+/** Split a slash-command argument string, honouring single and double quotes. */
+export function tokenizeImportArgs(raw) {
+    const tokens = [];
+    const pattern = /"([^"]*)"|'([^']*)'|(\S+)/g;
+    for (const match of raw.matchAll(pattern)) {
+        tokens.push(match[1] ?? match[2] ?? match[3] ?? "");
+    }
+    return tokens;
+}
+function parseTimestamp(raw, endOfDay) {
+    if (/^\d+$/.test(raw))
+        return Number(raw);
+    const parsed = Date.parse(raw);
+    if (!Number.isFinite(parsed))
+        return undefined;
+    // A bare YYYY-MM-DD parses to UTC midnight; an inclusive end date covers that whole day.
+    return endOfDay && /^\d{4}-\d{2}-\d{2}$/.test(raw) ? parsed + 86_399_999 : parsed;
+}
+function positiveInt(raw) {
+    const parsed = Number(raw);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+export function parseHistoryImportArgs(tokens, options) {
+    const result = {
+        help: false,
+        dryRun: false,
+        force: false,
+        skipMemories: false,
+        skipProfile: false,
+        scope: "current-project",
+        pathMaps: [],
+        errors: [],
+    };
+    const sourceFlag = SOURCE_FLAG[options.host];
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        const equals = token.startsWith("--") ? token.indexOf("=") : -1;
+        const flag = equals === -1 ? token : token.slice(0, equals);
+        if (BOOLEAN_FLAGS.has(flag)) {
+            if (equals !== -1) {
+                result.errors.push(`${flag} takes no value`);
+                continue;
+            }
+            if (flag === "--help" || flag === "-h")
+                result.help = true;
+            else if (flag === "--dry-run")
+                result.dryRun = true;
+            else if (flag === "--force")
+                result.force = true;
+            else if (flag === "--skip-memories")
+                result.skipMemories = true;
+            else
+                result.skipProfile = true;
+            continue;
+        }
+        if (!VALUE_FLAGS.has(flag) || ((flag === "--root" || flag === "--db") && flag !== sourceFlag)) {
+            result.errors.push(`Unknown option: "${token}"`);
+            continue;
+        }
+        if (CLI_ONLY_FLAGS.has(flag) && options.surface !== "cli") {
+            result.errors.push(`${flag} is only for the om-memory-system CLI; use --model provider/id`);
+            continue;
+        }
+        let value;
+        if (equals !== -1) {
+            value = token.slice(equals + 1);
+        }
+        else {
+            const next = tokens[i + 1];
+            value = next !== undefined && !next.startsWith("--") ? next : "";
+            if (value)
+                i++;
+        }
+        if (!value) {
+            result.errors.push(`${flag} requires a value`);
+            continue;
+        }
+        switch (flag) {
+            case "--profile-batch":
+                result.profileBatch = positiveInt(value);
+                if (result.profileBatch === undefined)
+                    result.errors.push("--profile-batch needs a positive integer");
+                break;
+            case "--max-sessions":
+                result.maxSessions = positiveInt(value);
+                if (result.maxSessions === undefined)
+                    result.errors.push("--max-sessions needs a positive integer");
+                break;
+            case "--model":
+                result.model = value;
+                break;
+            case "--scope":
+                if (value === "current-project" || value === "all-projects")
+                    result.scope = value;
+                else
+                    result.errors.push(`--scope must be current-project or all-projects, got "${value}"`);
+                break;
+            case "--project":
+                result.project = value;
+                break;
+            case "--session":
+                result.session = value;
+                break;
+            case "--since":
+            case "--until":
+                {
+                    const parsed = parseTimestamp(value, flag === "--until");
+                    if (parsed === undefined)
+                        result.errors.push(`${flag} is not a valid date: "${value}"`);
+                    else if (flag === "--since")
+                        result.since = parsed;
+                    else
+                        result.until = parsed;
+                }
+                break;
+            case "--map": {
+                const separator = value.indexOf("=");
+                if (separator > 0 && separator < value.length - 1) {
+                    result.pathMaps.push({ from: value.slice(0, separator), to: value.slice(separator + 1) });
+                }
+                else {
+                    result.errors.push(`--map must be <oldPath>=<newPath>, got "${value}"`);
+                }
+                break;
+            }
+            case "--root":
+            case "--db":
+                result.source = value;
+                break;
+            case "--provider":
+                result.provider = value;
+                break;
+            case "--api-url":
+                result.apiUrl = value;
+                break;
+            case "--api-key-env":
+                result.apiKeyEnv = value;
+                break;
+        }
+    }
+    if (result.since !== undefined && result.until !== undefined && result.since > result.until) {
+        result.errors.push("--since must be before --until");
+    }
+    if (result.project !== undefined && result.scope === "all-projects") {
+        result.errors.push("--project cannot be combined with --scope=all-projects");
+    }
+    if (options.surface === "session" && result.model !== undefined) {
+        const separator = result.model.indexOf("/");
+        if (separator < 1 || separator === result.model.length - 1) {
+            result.errors.push(`--model must be provider/id, got "${result.model}"`);
+        }
+    }
+    return result;
+}
+/** True when the run calls a model: a real import of memories or the profile. */
+export function importNeedsModel(args) {
+    return !args.dryRun && (!args.skipMemories || !args.skipProfile);
+}
+export function historyImportUsage(host, surface) {
+    const name = host === "pi" ? "pi" : "opencode";
+    const invoke = surface === "session"
+        ? `/memory-import-${name}-history`
+        : `om-memory-system import-${name}-history`;
+    const source = host === "pi"
+        ? "  --root <dir>              Pi session root (default ~/.pi/agent/sessions)"
+        : "  --db <path>               OpenCode database (default ~/.local/share/opencode/opencode.db)";
+    const model = surface === "session"
+        ? `  --model <provider/id>     Use another signed-in model (default: this session's model)`
+        : `  --model <id>              Model id (default: saved memoryModel)
+  --provider <type>         Provider type (default: saved memoryProvider)
+  --api-url <url>           Endpoint; required when --provider differs from the saved one
+  --api-key-env <name>      Read the API key from this environment variable`;
+    return `Usage: ${invoke} [options]
+
+Preview first: ${invoke} --dry-run
+
+Options:
+  --dry-run                 Preview counts; no model calls or writes
+${model}
+  --scope <scope>           current-project (default) or all-projects
+  --project <dir>           Project for current-project scope (default: working directory)
+  --session <id>            Import one session
+  --since <date>            Inclusive start (ISO 8601 or epoch ms)
+  --until <date>            Inclusive end; a bare date covers the whole day
+  --max-sessions <n>        Read at most n sessions, oldest first
+  --map <old>=<new>         Map a recorded directory that no longer exists (repeatable)
+${source}
+  --skip-memories           Record profile prompts only
+  --skip-profile            Import memories only
+  --profile-batch <n>       Prompts per profile analysis batch (default: 50)
+  --force                   Reprocess already-handled memory work units
+  --help                    Show this help
+
+Values may follow the flag or use --flag=value.`;
+}

package/dist/importer/importer.d.ts

@@ -1,15 +1,14 @@
-import type { CaptureSummaryProvider } from "../core/host.js";
-import { type PiConversationWindow } from "../adapters/pi/conversation.js";
+import type { CaptureConversation, CaptureSummaryProvider } from "../core/host.js";
+import type { ModelPort } from "../core/profile-analysis.js";
+import type { ProfileImportReport } from "./profile-import.js";
 import { PiImportLedger } from "./ledger.js";
 import type { LoadedPiSession } from "./session-loader.js";
+import type { MemoryHost } from "../types/index.js";
 /**
- * Host-neutral orchestration for the Pi historical-session backfill.
+ * Historical-session import orchestration for both hosts.
  *
- * Per unit: deterministic key -> ledger state -> (reconcile | capture ->
- * terminal ledger state). Per session: load through Pi's session model,
- * resolve the recorded cwd through the shared project identity, select the
- * active branch, and rebuild the same work units live capture would have
- * produced. Source files are only ever read.
+ * The shared source pipeline handles capture and ledger reconciliation.
+ * The Pi adapter discovers sessions and selects conversation windows.
  */
 export interface ImportPathMap {
     from: string;
@@ -26,6 +25,8 @@ export interface ImportFilters {
     maxSessions?: number;
     force?: boolean;
     dryRun?: boolean;
+    /** Record profile prompts only; leave memory work units untouched. */
+    skipMemories?: boolean;
     pathMaps?: ImportPathMap[];
     root?: string;
 }
@@ -70,18 +71,41 @@ export interface ImportReport {
     skipReasons: Record<string, number>;
     projects: ImportProjectReport[];
     units: ImportUnitReport[];
+    profile?: ProfileImportReport;
 }
 export interface ImporterDeps {
     loadSession: (file: string) => LoadedPiSession;
     provider: CaptureSummaryProvider;
     onProgress?: (processed: number, total: number, promptPreview: string) => void;
     ledger?: PiImportLedger;
+    profile?: {
+        model?: ModelPort;
+        batchSize?: number;
+    };
 }
-export declare function buildImportKey(sessionId: string, window: PiConversationWindow): string | null;
+export interface ImportWindow extends CaptureConversation {
+    userEntryId: string;
+    userPrompt: string;
+    userTimestamp?: number;
+}
+export interface ImportSourceSession {
+    sessionId: string;
+    directory: string;
+    sourceFile: string;
+    units: ImportWindow[];
+}
+export declare function buildImportKey(sessionId: string, window: ImportWindow, host?: string): string | null;
 /**
  * Find a stored memory by its deterministic import identity. Used to
  * reconcile crash windows: the memory insert landed but the ledger update did
  * not commit.
  */
 export declare function findMemoryIdByImportId(projectHash: string, importId: string): Promise<string | null>;
+/**
+ * Project tag for scope filtering only. Symlinked paths (macOS /var vs
+ * /private/var) name one project, so compare through the real path.
+ */
+export declare function projectFilterTag(directory: string): string;
+/** Process host-labelled work units through the shared capture and ledger pipeline. */
+export declare function importHistorySource(source: AsyncIterable<ImportSourceSession> | Iterable<ImportSourceSession>, host: MemoryHost, deps: Pick<ImporterDeps, "provider" | "ledger" | "onProgress">, filters: Pick<ImportFilters, "dryRun" | "force" | "since" | "until">, report: ImportReport): Promise<void>;
 export declare function importPiHistory(deps: ImporterDeps, filters: ImportFilters): Promise<ImportReport>;