@audiofool/moondog 0.1.0 → 0.2.0-beta.3

package/scripts/demo-studio.mjs

@@ -1,58 +0,0 @@
-#!/usr/bin/env node
-
-import {
-  MOONDOG_STUDIO_MAXIMUM_ARCHIVES,
-  runMoondogStudio,
-} from "../src/surfaces/web/studio.mjs";
-
-const usage = `Usage:
-  npm run demo:studio
-  npm run demo:studio -- --from <spotify-history.zip> [--from <spotify-history.zip>]
-
-Without --from, Moondog opens the fictional production-importer tour.
-With one or two explicitly supplied ZIPs, it opens a session-only private profile without installing dependencies or writing persistent profile state.`;
-
-function terminalText(value) {
-  return String(value ?? "Unknown failure")
-    .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/gu, " ")
-    .replace(/[\u202a-\u202e\u2066-\u2069]/gu, "")
-    .slice(0, 1_000);
-}
-
-async function main() {
-  const values = process.argv.slice(2);
-  if (values.length === 1 && new Set(["--help", "-h"]).has(values[0])) {
-    process.stdout.write(`${usage}\n`);
-    return;
-  }
-  if (values.length === 0) {
-    await runMoondogStudio({ demoOnly: true });
-    return;
-  }
-
-  const archivePaths = [];
-  for (let index = 0; index < values.length; index += 2) {
-    const option = values[index];
-    const archivePath = values[index + 1];
-    if (
-      option !== "--from" ||
-      !archivePath ||
-      archivePath.startsWith("--")
-    ) {
-      throw new Error(usage);
-    }
-    archivePaths.push(archivePath);
-  }
-  if (
-    archivePaths.length < 1 ||
-    archivePaths.length > MOONDOG_STUDIO_MAXIMUM_ARCHIVES
-  ) {
-    throw new Error(usage);
-  }
-  await runMoondogStudio({ archivePaths });
-}
-
-main().catch((error) => {
-  process.stderr.write(`moondog demo studio: ${terminalText(error?.message)}\n`);
-  process.exitCode = 1;
-});

package/src/core/apple-data-migration.mjs

@@ -1,50 +0,0 @@
-import { cp, lstat, mkdir } from "node:fs/promises";
-import path from "node:path";
-
-import { legacyAppleMusicImportsRoot, resolveAppleMusicImportsRoot } from "./apple-library-source-status.mjs";
-import { resolveAppleMusicProjectionPath } from "./apple-projection-domain-services.mjs";
-import { legacyAppleMusicProjectionPath } from "../importers/apple-music-library/index.mjs";
-
-async function kind(target) {
-  try {
-    const metadata = await lstat(target);
-    return metadata.isSymbolicLink() ? "link" : metadata.isDirectory() ? "directory" : "file";
-  } catch (error) {
-    if (error?.code === "ENOENT") return null;
-    throw error;
-  }
-}
-
-async function copyOnce(from, to, expected) {
-  if ((await kind(from)) !== expected || (await kind(to)) !== null) return false;
-  await mkdir(path.dirname(to), { recursive: true, mode: 0o700 });
-  await cp(from, to, { recursive: true, errorOnExist: true, force: false, preserveTimestamps: true });
-  return true;
-}
-
-/**
- * Earlier versions kept Apple Music data inside the source checkout. Copy it
- * into the default private state directory once, leaving the original in
- * place. Runs with an explicit state or Apple location are never touched, so
- * isolated runs such as tests cannot pull private data into their directories.
- */
-export async function migrateLegacyAppleMusicData(environment = process.env) {
-  const explicit = [
-    "MOONDOG_STATE_HOME",
-    "MOONDOG_CONFIG_HOME",
-    "MOONDOG_APPLE_IMPORTS_ROOT",
-    "MOONDOG_APPLE_PROJECTION_PATH",
-  ].some((name) => environment[name]?.trim());
-  if (explicit) return { copied: [] };
-  const copied = [];
-  if (await copyOnce(legacyAppleMusicImportsRoot, resolveAppleMusicImportsRoot(environment), "directory")) {
-    copied.push("imports");
-  }
-  if (await copyOnce(legacyAppleMusicProjectionPath, resolveAppleMusicProjectionPath(environment), "file")) {
-    copied.push("projection");
-    for (const suffix of ["-wal", "-shm"]) {
-      await copyOnce(`${legacyAppleMusicProjectionPath}${suffix}`, `${resolveAppleMusicProjectionPath(environment)}${suffix}`, "file");
-    }
-  }
-  return { copied };
-}

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

@@ -1,293 +0,0 @@
-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,
-    };
-  }
-}