@audiofool/moondog 0.1.0

package/src/demo/moondog-demo.mjs

@@ -0,0 +1,355 @@
+import { MoondogApplication } from "../core/moondog-application.mjs";
+import { createSyntheticDomainServices } from "../core/synthetic-domain-services.mjs";
+import { createConfiguredRuntime } from "../runtime/pi/configured-runtime.mjs";
+
+export const MOONDOG_DEMO_PROMPT =
+  "Build a six-track late-night drive playlist from the demo library. Start familiar, then add a measured amount of surprise. Inspect and explain at least one key profile evidence record before planning. Explain the ordering. Do not save or play anything.";
+
+const demoSubjectId = "10000000-0000-4000-8000-000000000000";
+
+const offlineSelection = Object.freeze([
+  Object.freeze({
+    title: "Midnight Lines",
+    reason:
+      "An explicit loved and rated signal plus high familiarity makes this a grounded opening anchor.",
+  }),
+  Object.freeze({
+    title: "Glass Highway",
+    reason:
+      "A favorited track with high familiarity keeps the opening inside established evidence.",
+  }),
+  Object.freeze({
+    title: "Blue Exit",
+    reason:
+      "Medium familiarity makes this a measured bridge away from the two strongest anchors.",
+  }),
+  Object.freeze({
+    title: "Soft Static",
+    reason:
+      "Low familiarity introduces a bounded surprise without claiming that the track is new or preferred.",
+  }),
+  Object.freeze({
+    title: "Empty Overpass",
+    reason:
+      "One observed play makes this the largest familiarity stretch in the sequence.",
+  }),
+  Object.freeze({
+    title: "First Light Behind Us",
+    reason:
+      "Medium familiarity and a favorited artist return the close toward established evidence.",
+  }),
+]);
+
+const offlineSteps = Object.freeze({
+  profile: Object.freeze({
+    tool: "moondog_profile_summary",
+    capability: "profile.summary",
+    label: "Read the synthetic music profile",
+  }),
+  evidence: Object.freeze({
+    tool: "moondog_profile_explain",
+    capability: "profile.explain",
+    label: "Inspect one profile evidence record",
+  }),
+  search: Object.freeze({
+    tool: "moondog_library_search",
+    capability: "library.search",
+    label: "Search the synthetic library",
+  }),
+  plan: Object.freeze({
+    tool: "moondog_playlist_plan",
+    capability: "playlist.plan",
+    label: "Validate the playlist plan",
+  }),
+});
+
+const demoNextSteps = Object.freeze([
+  Object.freeze({
+    id: "open_visual_tour",
+    title: "Open the visual Listening Time Machine",
+    checkout_command: "npm run demo:studio",
+    installed_command: "moondog studio --demo",
+    data_boundary:
+      "The fictional tour stays on 127.0.0.1, reads no private history, rejects imports, and keeps corrections only in process memory.",
+  }),
+  Object.freeze({
+    id: "open_session_studio",
+    title: "Open your history without importing it",
+    checkout_command:
+      "npm --silent run demo:studio -- --from /absolute/path/to/spotify-history.zip",
+    installed_command:
+      "moondog studio --from /absolute/path/to/spotify-history.zip",
+    data_boundary:
+      "No dependency installation is required. The archive stays unchanged, the private profile and corrections live only in process memory, and no model, provider, cloud, or network request is made.",
+  }),
+  Object.freeze({
+    id: "open_private_studio",
+    title: "Bring your own listening history",
+    checkout_command: "npm run studio",
+    installed_command: "moondog studio",
+    data_boundary:
+      "Studio stays on 127.0.0.1. The fictional preview saves nothing. Import changes private local state only after an explicit button press.",
+  }),
+]);
+
+function createDemoNextSteps() {
+  return demoNextSteps.map((step) => ({ ...step }));
+}
+
+class DemoApplication extends MoondogApplication {
+  async sourceStatus() {
+    return {
+      source: "synthetic_demo_library",
+      state: "ready",
+      valid_batches: 1,
+      invalid_batches: 0,
+      latest: {
+        captured_at: "2026-08-25T00:00:00.000Z",
+        tracks: 8,
+        playlists: 0,
+        playlist_item_references: 0,
+        aggregate_track_snapshots: 8,
+        listening_events: 0,
+        taste_events: 0,
+        loved_or_favorited_coverage: 4,
+        aggregate_play_count_coverage: 7,
+      },
+      semantics: {
+        library_snapshot_available: true,
+        complete_listening_history_available: false,
+        profile_materialization_ready: true,
+      },
+    };
+  }
+
+  async profileStatus() {
+    return {
+      state: "ready",
+      projection_version: "profile_projection/0",
+      evidence_records: 5,
+      claims: 0,
+      reason:
+        "The public demo uses an explicitly synthetic, bounded music profile.",
+    };
+  }
+}
+
+function cleanDemoPrompt(value) {
+  if (value === undefined) return MOONDOG_DEMO_PROMPT;
+  if (typeof value !== "string") {
+    throw new TypeError("The demo prompt must be text.");
+  }
+  const cleaned = value
+    .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/gu, "")
+    .replace(/[\u202a-\u202e\u2066-\u2069]/gu, "")
+    .replace(/\s+/gu, " ")
+    .trim();
+  if (!cleaned || Array.from(cleaned).length > 1_000) {
+    throw new TypeError("The demo prompt must contain 1 to 1000 characters.");
+  }
+  return cleaned;
+}
+
+function createDemoApplication() {
+  return new DemoApplication({
+    importsRoot: "/moondog/synthetic-demo/does-not-read-local-imports",
+    domainServices: createSyntheticDomainServices({
+      subjectScope: { subjectId: demoSubjectId },
+    }),
+  });
+}
+
+async function captureOfflineStep(trace, step, action) {
+  const entry = {
+    sequence: trace.length + 1,
+    tool: step.tool,
+    capability: step.capability,
+    label: step.label,
+    status: "running",
+  };
+  trace.push(entry);
+  try {
+    const result = await action();
+    entry.status = "completed";
+    return result;
+  } catch (error) {
+    entry.status = "failed";
+    throw error;
+  }
+}
+
+function offlineResultText(profile, evidence, plan) {
+  const preference = profile.strong_preferences[0];
+  return [
+    `Profile anchor: ${preference.label} - ${preference.signal}.`,
+    `Evidence checked: ${evidence.basis_summary}`,
+    "",
+    ...plan.tracks.map(
+      (track) =>
+        `${track.position}. ${track.title} - ${track.artist_credit}\n   ${track.selection_reason}`,
+    ),
+    "",
+    `Ordering: ${plan.ordering_rationale}`,
+    "Grounding boundary: play count supports familiarity, not liking; low familiarity does not prove novelty.",
+    "Action boundary: the host validated track identity, candidate membership, count, and order without saving or playing anything.",
+  ].join("\n");
+}
+
+async function runOfflineDemo(application, prompt) {
+  const trace = [];
+  application.beginPrompt();
+  try {
+    const profile = await captureOfflineStep(
+      trace,
+      offlineSteps.profile,
+      () => application.getProfileSummary({ maxItems: 6 }),
+    );
+    const evidenceId = profile.strong_preferences[0]?.evidence_id;
+    if (!evidenceId) {
+      throw new Error("The synthetic demo profile has no explainable preference evidence.");
+    }
+    const evidence = await captureOfflineStep(
+      trace,
+      offlineSteps.evidence,
+      () => application.explainProfileEvidence({ evidenceId }),
+    );
+    const search = await captureOfflineStep(
+      trace,
+      offlineSteps.search,
+      () => application.searchLibrary({ query: "night drive", limit: 8 }),
+    );
+    const tracksByTitle = new Map(
+      search.tracks.map((track) => [track.title, track]),
+    );
+    const selections = offlineSelection.map((selection) => {
+      const track = tracksByTitle.get(selection.title);
+      if (!track) {
+        throw new Error(
+          `The synthetic demo library is missing ${selection.title}.`,
+        );
+      }
+      return {
+        trackRefId: track.track_ref_id,
+        selectionReason: selection.reason,
+      };
+    });
+    const plan = await captureOfflineStep(
+      trace,
+      offlineSteps.plan,
+      () =>
+        application.buildPlaylistPlan({
+          intent: prompt,
+          requestedTrackCount: selections.length,
+          candidateSetIds: [search.candidate_set_id],
+          trackRefs: selections,
+          orderingNotes:
+            "Start with two explicit preference anchors, cross a medium-familiarity bridge, introduce two low-familiarity tracks, then close with a favorited artist.",
+        }),
+    );
+    return {
+      demo_version: "moondog-demo/3",
+      mode: "synthetic_offline_read_only",
+      prompt,
+      runtime: {
+        provider: "none",
+        model: "deterministic-showcase/1",
+      },
+      coverage: {
+        library_tracks: 8,
+        profile_evidence: 5,
+        external_effects: "disabled",
+      },
+      tool_trace: trace,
+      result: {
+        status: "completed",
+        text: offlineResultText(profile, evidence, plan),
+        playlist_plan: structuredClone(plan),
+      },
+      limitations: [
+        "The library and profile are synthetic demonstration data.",
+        "The offline walkthrough is deterministic and does not call a language model or music service.",
+        "The demo cannot write playlists, control playback, or access private local music data.",
+        "This walkthrough proves the grounded product path, not subjective curation quality.",
+      ],
+      next_steps: createDemoNextSteps(),
+    };
+  } finally {
+    application.endPrompt();
+  }
+}
+
+export async function runMoondogDemo({
+  prompt,
+  offline = false,
+  runtimeBuilder = createConfiguredRuntime,
+} = {}) {
+  const demoPrompt = cleanDemoPrompt(prompt);
+  const application = createDemoApplication();
+  let runtime;
+  try {
+    if (offline) return await runOfflineDemo(application, demoPrompt);
+    runtime = await runtimeBuilder(application);
+    const runtimeStatus = runtime.publicStatus();
+    if (runtimeStatus.state !== "configured") {
+      const error = new Error(
+        "The Moondog demo needs a configured model. Run moondog, then use /auth and /model before retrying moondog demo.",
+      );
+      error.code = runtimeStatus.reason ?? "model_not_configured";
+      throw error;
+    }
+
+    const trace = [];
+    const traceByCallId = new Map();
+    const result = await runtime.prompt(demoPrompt, {
+      onToolStart(event) {
+        const entry = {
+          sequence: trace.length + 1,
+          tool: event.toolName,
+          capability: event.capabilityId,
+          label: event.label,
+          status: "running",
+        };
+        trace.push(entry);
+        traceByCallId.set(event.toolCallId, entry);
+      },
+      onToolEnd(event) {
+        const entry = traceByCallId.get(event.toolCallId);
+        if (!entry) return;
+        entry.status = event.isError ? "failed" : "completed";
+      },
+    });
+
+    return {
+      demo_version: "moondog-demo/2",
+      mode: "synthetic_read_only",
+      prompt: demoPrompt,
+      runtime: {
+        provider: runtimeStatus.provider,
+        model: runtimeStatus.model,
+      },
+      coverage: {
+        library_tracks: 8,
+        profile_evidence: 5,
+        external_effects: "disabled",
+      },
+      tool_trace: trace,
+      result: {
+        status: result.status,
+        text: result.text,
+        ...(result.playlist_plan
+          ? { playlist_plan: structuredClone(result.playlist_plan) }
+          : {}),
+      },
+      limitations: [
+        "The library and profile are synthetic demonstration data.",
+        "The demo calls the configured model provider but no music service.",
+        "The demo cannot write playlists, control playback, or access private local music data.",
+        "One model response is a product walkthrough, not a curation benchmark.",
+      ],
+      next_steps: createDemoNextSteps(),
+    };
+  } finally {
+    runtime?.abort?.();
+    application.close();
+  }
+}

package/src/demo/moondog-interactive-tasteprint-demo.mjs

@@ -0,0 +1,293 @@
+import {
+  createListenerCorrection,
+  createListenerCorrectionRetraction,
+  listenerCorrectionTargetKey,
+} from "../profile/listener-corrections.mjs";
+import { createPublicTasteprintDemoProfile } from "./moondog-tasteprint-demo.mjs";
+
+const DEMO_SUBJECT_ID = "70000000-0000-4000-8000-000000000001";
+
+function demoCorrectionError(code, message) {
+  const error = new Error(message);
+  error.name = "ListenerCorrectionError";
+  error.code = code;
+  return error;
+}
+
+function activeAssertions(records) {
+  const retracted = new Set(
+    records
+      .filter((record) => record.operation === "retract")
+      .map((record) => record.retracts_taste_event_id),
+  );
+  const superseded = new Set(
+    records
+      .filter((record) => record.operation === "assert")
+      .map((record) => record.supersedes_taste_event_id)
+      .filter(Boolean),
+  );
+  return records
+    .filter(
+      (record) =>
+        record.operation === "assert" &&
+        !retracted.has(record.taste_event_id) &&
+        !superseded.has(record.taste_event_id),
+    )
+    .sort((left, right) => {
+      const time = right.recorded_at.localeCompare(left.recorded_at);
+      return time || right.taste_event_id.localeCompare(left.taste_event_id);
+    });
+}
+
+function publicCorrection(record) {
+  const artistCredit = record.extensions?.["moondog.artist_credit"];
+  return {
+    correction_id: record.taste_event_id,
+    state: "active",
+    entity_type: record.target.entity_type,
+    label: record.target.label,
+    ...(artistCredit ? { artist_credit: artistCredit } : {}),
+    stance: record.signal_type === "avoidance" ? "avoid" : "like",
+    occurred_at: record.occurred_at,
+    ...(record.note ? { note: record.note } : {}),
+  };
+}
+
+function projectedAssertion(record) {
+  const correction = publicCorrection(record);
+  return {
+    correction_id: correction.correction_id,
+    evidence_id: correction.correction_id,
+    entity_type: correction.entity_type,
+    label: correction.label,
+    ...(correction.artist_credit
+      ? { artist_credit: correction.artist_credit }
+      : {}),
+    stance: correction.stance,
+    strength: 1,
+    asserted_at: correction.occurred_at,
+    ...(correction.note ? { note: correction.note } : {}),
+  };
+}
+
+function normalizedText(value) {
+  return String(value).normalize("NFKC").toLocaleLowerCase("und").trim();
+}
+
+function strongPreferenceAvoided(item, avoids) {
+  const label = normalizedText(item.label);
+  return avoids.some((avoid) => {
+    if (normalizedText(avoid.label) !== label) return false;
+    if (avoid.entity_type === "track") return true;
+    return /artist/iu.test(item.signal ?? "");
+  });
+}
+
+function behaviorTrackAvoided(item, avoids) {
+  const label = normalizedText(item?.label);
+  const artist = normalizedText(item?.artist_credit);
+  return avoids.some((avoid) => {
+    if (avoid.entity_type === "artist") {
+      return artist && artist === normalizedText(avoid.label);
+    }
+    if (avoid.entity_type !== "track" || label !== normalizedText(avoid.label)) {
+      return false;
+    }
+    return !avoid.artist_credit ||
+      artist === normalizedText(avoid.artist_credit);
+  });
+}
+
+function directPreference(assertion, kind) {
+  return {
+    label: assertion.artist_credit
+      ? `${assertion.label} / ${assertion.artist_credit}`
+      : assertion.label,
+    signal: `Direct ${kind === "demo" ? "demo" : "session"} ${assertion.entity_type} preference`,
+  };
+}
+
+export class InteractiveTasteprintDemoSession {
+  #records = [];
+  #baseProfileFactory;
+  #kind;
+
+  constructor({
+    baseProfileFactory = createPublicTasteprintDemoProfile,
+    kind = "demo",
+  } = {}) {
+    if (typeof baseProfileFactory !== "function") {
+      throw new TypeError("The interactive demo profile factory is invalid.");
+    }
+    if (!new Set(["demo", "private_session"]).has(kind)) {
+      throw new TypeError("The interactive profile session kind is invalid.");
+    }
+    this.#baseProfileFactory = baseProfileFactory;
+    this.#kind = kind;
+  }
+
+  get activeCount() {
+    return activeAssertions(this.#records).length;
+  }
+
+  corrections() {
+    return activeAssertions(this.#records).map(publicCorrection);
+  }
+
+  profile() {
+    const profile = this.#baseProfileFactory();
+    if (!profile || typeof profile !== "object" || Array.isArray(profile)) {
+      throw new TypeError("The interactive demo base profile is invalid.");
+    }
+    const active = activeAssertions(this.#records).map(projectedAssertion);
+    const preferences = active.filter((item) => item.stance === "like");
+    const avoids = active.filter((item) => item.stance === "avoid");
+    const assertions = this.#records.filter(
+      (record) => record.operation === "assert",
+    ).length;
+    const retractions = this.#records.filter(
+      (record) => record.operation === "retract",
+    ).length;
+    profile.coverage = {
+      ...profile.coverage,
+      listener_assertion_events: assertions,
+      active_listener_assertions: active.length,
+      listener_retractions: retractions,
+    };
+    profile.listener_assertions = {
+      active,
+      preferences,
+      avoids,
+      retractions,
+    };
+    profile.strong_preferences = [
+      ...preferences.map((item) => directPreference(item, this.#kind)),
+      ...profile.strong_preferences.filter(
+        (item) => !strongPreferenceAvoided(item, avoids),
+      ),
+    ].slice(0, 10);
+    profile.curated_preferences = {
+      ...profile.curated_preferences,
+      avoids: avoids.map((item) => ({
+        entity_type: item.entity_type,
+        label: item.label,
+        ...(item.artist_credit
+          ? { artist_credit: item.artist_credit }
+          : {}),
+        stance: "avoid",
+      })),
+    };
+    if (profile.listening_behavior) {
+      // Refilter every listen-again selection from the original bounded profile.
+      // Descriptive history remains evidence even when the listener avoids it.
+      // Retraction restores the original candidates without inventing replacements.
+      profile.listening_behavior = { ...profile.listening_behavior };
+      for (const key of [
+        "rediscovery_tracks",
+        "time_capsule_tracks",
+        "historical_return_tracks",
+        "back_to_back_tracks",
+      ]) {
+        const candidates = profile.listening_behavior[key];
+        if (Array.isArray(candidates)) {
+          profile.listening_behavior[key] = candidates.filter(
+            (item) => !behaviorTrackAvoided(item, avoids),
+          );
+        }
+      }
+    }
+    profile.limitations = [
+      this.#kind === "demo"
+        ? "Interactive demo corrections exist only in this Studio process and disappear when it stops."
+        : "Session-only corrections exist only in this Studio process and disappear when it stops.",
+      ...profile.limitations,
+    ].slice(0, 8);
+    return profile;
+  }
+
+  record({
+    entityType,
+    label,
+    artistCredit,
+    stance,
+    note,
+    occurredAt,
+    recordedAt = occurredAt,
+  } = {}) {
+    const initial = createListenerCorrection({
+      subjectId: DEMO_SUBJECT_ID,
+      entityType,
+      label,
+      artistCredit,
+      stance,
+      note,
+      occurredAt,
+      recordedAt,
+    });
+    const previous = activeAssertions(this.#records).find(
+      (record) => listenerCorrectionTargetKey(record) === initial.targetKey,
+    );
+    const value = previous
+      ? createListenerCorrection({
+          subjectId: DEMO_SUBJECT_ID,
+          entityType,
+          label,
+          artistCredit,
+          stance,
+          note,
+          occurredAt,
+          recordedAt,
+          correctionId: initial.record.taste_event_id,
+          supersedesCorrectionId: previous.taste_event_id,
+        })
+      : initial;
+    this.#records.push(value.record);
+    return publicCorrection(value.record);
+  }
+
+  retract({
+    correctionId,
+    occurredAt,
+    recordedAt = occurredAt,
+  } = {}) {
+    const assertion = this.#records.find(
+      (record) =>
+        record.operation === "assert" &&
+        record.taste_event_id === correctionId?.toLocaleLowerCase("en-US"),
+    );
+    if (!assertion) {
+      throw demoCorrectionError(
+        "listener_correction_not_found",
+        this.#kind === "demo"
+          ? "The demo listener correction was not found."
+          : "The session-only listener correction was not found.",
+      );
+    }
+    if (
+      !activeAssertions(this.#records).some(
+        (record) => record.taste_event_id === assertion.taste_event_id,
+      )
+    ) {
+      throw demoCorrectionError(
+        "listener_correction_inactive",
+        this.#kind === "demo"
+          ? "Only an active demo listener correction can be retracted."
+          : "Only an active session-only listener correction can be retracted.",
+      );
+    }
+    const retraction = createListenerCorrectionRetraction({
+      subjectId: DEMO_SUBJECT_ID,
+      retractsCorrectionId: assertion.taste_event_id,
+      occurredAt,
+      recordedAt,
+    });
+    this.#records.push(retraction);
+    return {
+      state: "retracted",
+      correction_id: assertion.taste_event_id,
+      retraction_id: retraction.taste_event_id,
+      entity_type: assertion.target.entity_type,
+      label: assertion.target.label,
+    };
+  }
+}