@jcendal/opencode-digital-pet 0.2.0-dev.0

package/dist/digital-pet-core/config/defaults.d.ts

@@ -0,0 +1,68 @@
+export declare const DIGITAL_PET_STAGE_LABELS: Readonly<{
+    readonly en: Readonly<{
+        readonly egg: "DigiEgg";
+        readonly babyI: "In Training I";
+        readonly babyII: "In Training II";
+        readonly child: "Rookie";
+        readonly adult: "Champion";
+        readonly perfect: "Ultimate";
+        readonly ultimate: "Mega";
+        readonly superUltimate: "Ultra";
+    }>;
+    readonly jp: Readonly<{
+        readonly egg: "Digitama";
+        readonly babyI: "Baby I";
+        readonly babyII: "Baby II";
+        readonly child: "Child";
+        readonly adult: "Adult";
+        readonly perfect: "Perfect";
+        readonly ultimate: "Ultimate";
+        readonly superUltimate: "SuperUltimate";
+    }>;
+}>;
+export declare const DEFAULT_STAGE_THRESHOLDS: Readonly<{
+    readonly egg: 5000000;
+    readonly babyI: 10000000;
+    readonly babyII: 20000000;
+    readonly child: 40000000;
+    readonly adult: 75000000;
+    readonly perfect: 125000000;
+    readonly ultimate: 200000000;
+    readonly superUltimate: 300000000;
+}>;
+export declare const DEFAULT_DIGITAL_PET_SETTINGS: Readonly<{
+    readonly language: "jp";
+    readonly notifications: true;
+    readonly stageLabels: Readonly<{
+        readonly en: Readonly<{
+            readonly egg: "DigiEgg";
+            readonly babyI: "In Training I";
+            readonly babyII: "In Training II";
+            readonly child: "Rookie";
+            readonly adult: "Champion";
+            readonly perfect: "Ultimate";
+            readonly ultimate: "Mega";
+            readonly superUltimate: "Ultra";
+        }>;
+        readonly jp: Readonly<{
+            readonly egg: "Digitama";
+            readonly babyI: "Baby I";
+            readonly babyII: "Baby II";
+            readonly child: "Child";
+            readonly adult: "Adult";
+            readonly perfect: "Perfect";
+            readonly ultimate: "Ultimate";
+            readonly superUltimate: "SuperUltimate";
+        }>;
+    }>;
+    readonly stageThresholds: Readonly<{
+        readonly egg: 5000000;
+        readonly babyI: 10000000;
+        readonly babyII: 20000000;
+        readonly child: 40000000;
+        readonly adult: 75000000;
+        readonly perfect: 125000000;
+        readonly ultimate: 200000000;
+        readonly superUltimate: 300000000;
+    }>;
+}>;

package/dist/digital-pet-core/config/normalize.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedDigitalPetSettings } from "./types.js";
+export declare const normalizeDigitalPetSettings: (input: unknown) => ResolvedDigitalPetSettings;

package/dist/digital-pet-core/config/types.d.ts

@@ -0,0 +1,13 @@
+export declare const DIGITAL_PET_LANGUAGES: readonly ["en", "jp"];
+export type DigitalPetLanguage = (typeof DIGITAL_PET_LANGUAGES)[number];
+export declare const STAGE_THRESHOLD_KEYS: readonly ["egg", "babyI", "babyII", "child", "adult", "perfect", "ultimate", "superUltimate"];
+export type StageThresholdKey = (typeof STAGE_THRESHOLD_KEYS)[number];
+export type StageThresholdSettings = Readonly<Record<StageThresholdKey, number>>;
+export type StageLabels = Readonly<Record<StageThresholdKey, string>>;
+export type DigitalPetStageLabels = Readonly<Record<DigitalPetLanguage, StageLabels>>;
+export type ResolvedDigitalPetSettings = Readonly<{
+    readonly language: DigitalPetLanguage;
+    readonly notifications: boolean;
+    readonly stageLabels: DigitalPetStageLabels;
+    readonly stageThresholds: StageThresholdSettings;
+}>;

package/dist/digital-pet-core/data/catalog.d.ts

@@ -0,0 +1,14 @@
+import type { DigimonCatalog } from "../domain/digimon-node.js";
+export type { DigimonCatalog, DigimonNode } from "../domain/digimon-node.js";
+export type RawDigimonNode = {
+    readonly id: string;
+    readonly name_en: string;
+    readonly name_jp: string;
+    readonly next_evolutions: readonly string[];
+    readonly sprite: string;
+    readonly stage: number;
+    readonly url: string;
+};
+export declare const parseDigimonCatalog: (input: readonly RawDigimonNode[]) => DigimonCatalog;
+export declare const DIGIMON_CATALOG: DigimonCatalog;
+export declare const loadDigimonCatalog: () => Promise<DigimonCatalog>;

package/dist/digital-pet-core/data/digimon-data.d.ts

@@ -0,0 +1,12 @@
+export type DigimonStage = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
+export type DigimonId = `${DigimonStage}-${number}`;
+export type DigimonRecord = {
+    readonly name_en: string;
+    readonly name_jp: string;
+    readonly next_evolutions: readonly DigimonId[];
+    readonly stage: DigimonStage;
+    readonly sprite: string;
+    readonly id: DigimonId;
+    readonly url: string;
+};
+export declare const DIGIMON_DATA: readonly DigimonRecord[];

package/dist/digital-pet-core/data/monster-frame-catalog.d.ts

@@ -0,0 +1,16 @@
+export declare const MONSTER_FRAME_NAMES: readonly ["angry", "attack", "eat_1", "eat_2", "happy", "injured_1", "injured_2", "refuse", "sleep_1", "sleep_2", "walk_1", "walk_2"];
+export type MonsterFrameName = (typeof MONSTER_FRAME_NAMES)[number];
+export declare const STANDARD_ANIMATION_SEQUENCE: readonly ["angry", "attack", "eat_1", "eat_2", "happy", "injured_1", "injured_2", "sleep_1", "sleep_2", "walk_1", "walk_2"];
+type SpriteFrames = Iterable<readonly [MonsterFrameName, MonsterFrame]>;
+type CatalogFrames = Iterable<readonly [string, SpriteFrames]>;
+export declare class MonsterFrame {
+    readonly content: string;
+    constructor(content: string);
+}
+export declare class MonsterFrameCatalog {
+    #private;
+    constructor(frames: CatalogFrames);
+    get(sprite: string, frameName: MonsterFrameName): MonsterFrame | undefined;
+}
+export declare const MONSTER_FRAME_CATALOG: MonsterFrameCatalog;
+export {};

package/dist/digital-pet-core/data/monster-frame-data.d.ts

@@ -0,0 +1,2 @@
+import type { MonsterFrameName } from "./monster-frame-catalog.js";
+export declare const MONSTER_FRAME_DATA: readonly [string, readonly [MonsterFrameName, string][]][];

package/dist/digital-pet-core/data/stages.d.ts

@@ -0,0 +1,16 @@
+import type { StageLabels, StageThresholdKey } from "../config/types.js";
+import { isDigimonStage, type DigimonStage } from "../domain/stage.js";
+export { isDigimonStage, type DigimonStage };
+export declare const STAGE_VALUES: readonly [0, 1, 2, 3, 4, 5, 6, 7];
+export declare const STAGE_THRESHOLD_KEYS: {
+    readonly 0: "egg";
+    readonly 1: "babyI";
+    readonly 2: "babyII";
+    readonly 3: "child";
+    readonly 4: "adult";
+    readonly 5: "perfect";
+    readonly 6: "ultimate";
+    readonly 7: "superUltimate";
+};
+export declare const getStageKey: (stage: DigimonStage) => StageThresholdKey;
+export declare const getStageLabel: (stage: DigimonStage, labels: StageLabels) => string;

package/dist/digital-pet-core/domain/digimon-node.d.ts

@@ -0,0 +1,14 @@
+import type { DigimonStage } from "./stage.js";
+export type DigimonNode = {
+    readonly id: string;
+    readonly nameEn: string;
+    readonly nameJp: string;
+    readonly nextEvolutions: readonly string[];
+    readonly sprite: string;
+    readonly stage: DigimonStage;
+    readonly url: string;
+};
+export type DigimonCatalog = {
+    readonly nodes: readonly DigimonNode[];
+    readonly byId: ReadonlyMap<string, DigimonNode>;
+};

package/dist/digital-pet-core/domain/evolution-battle.d.ts

@@ -0,0 +1,4 @@
+import type { DigimonNode } from "./digimon-node.js";
+import type { EvolutionSelector } from "./evolution.js";
+export declare const pickEvolutionTarget: (current: DigimonNode, selector: EvolutionSelector) => string;
+export declare const pickRandomSameStageOpponent: (current: DigimonNode, catalogNodes: readonly DigimonNode[], selector: EvolutionSelector) => string;

package/dist/digital-pet-core/domain/evolution.d.ts

@@ -0,0 +1,23 @@
+import type { DigimonNode } from "./digimon-node.js";
+import { type DigimonStage } from "./stage.js";
+export type StageThresholds = Readonly<Record<DigimonStage, number>>;
+export declare const STAGE_GAUGE_THRESHOLDS: Readonly<{
+    readonly 0: 5000000;
+    readonly 1: 10000000;
+    readonly 2: 20000000;
+    readonly 3: 40000000;
+    readonly 4: 75000000;
+    readonly 5: 125000000;
+    readonly 6: 200000000;
+    readonly 7: 300000000;
+}>;
+export type PartnerEvolutionState = {
+    readonly current: DigimonNode;
+    readonly gauge: number;
+    readonly isTerminal: boolean;
+    readonly pendingEvolutionTargetId: string | null;
+    readonly battleOpponentNodeId: string | null;
+};
+export type EvolutionSelector = () => number;
+export declare const applyTokenProgress: (state: PartnerEvolutionState, tokenDelta: number, selector: EvolutionSelector, digimonById: ReadonlyMap<string, DigimonNode>, catalogNodes: readonly DigimonNode[], thresholds: unknown) => PartnerEvolutionState;
+export declare const resolveEvolutionBattle: (state: PartnerEvolutionState, won: boolean, digimonById: ReadonlyMap<string, DigimonNode>) => PartnerEvolutionState;

package/dist/digital-pet-core/domain/partner.d.ts

@@ -0,0 +1,18 @@
+export type Partner = {
+    readonly partnerId: string;
+    readonly generation: number;
+    readonly currentNodeId: string;
+    readonly gauge: number;
+    readonly isTerminal: boolean;
+    readonly pendingEvolutionTargetId: string | null;
+    readonly battleOpponentNodeId: string | null;
+    readonly createdAt: string;
+    readonly retiredAt: string | null;
+};
+export type PartnerProgression = {
+    readonly currentNodeId: string;
+    readonly gauge: number;
+    readonly isTerminal: boolean;
+    readonly pendingEvolutionTargetId: string | null;
+    readonly battleOpponentNodeId: string | null;
+};

package/dist/digital-pet-core/domain/stage.d.ts

@@ -0,0 +1,3 @@
+export declare const DIGIMON_STAGES: readonly [0, 1, 2, 3, 4, 5, 6, 7];
+export type DigimonStage = (typeof DIGIMON_STAGES)[number];
+export declare const isDigimonStage: (value: number) => value is DigimonStage;

package/dist/digital-pet-core/ports/sqlite-executor.d.ts

@@ -0,0 +1,7 @@
+export type QueryValue = string | number | boolean | null;
+export type SqliteExecutor = {
+    run: (sql: string, params?: readonly QueryValue[]) => void;
+    get: <TRow extends Record<string, QueryValue>>(sql: string, params?: readonly QueryValue[]) => TRow | null;
+    all: <TRow extends Record<string, QueryValue>>(sql: string, params?: readonly QueryValue[]) => readonly TRow[];
+    transaction: <TReturn>(operation: () => TReturn) => TReturn;
+};

package/dist/digital-pet-core/view-models/dex-view-model.d.ts

@@ -0,0 +1,19 @@
+import type { DigitalPetArchiveResult } from "../application/models/digital-pet-archive.js";
+import type { ResolvedDigitalPetSettings } from "../config/types.js";
+import type { DigimonCatalog } from "../data/catalog.js";
+export type DexRow = {
+    readonly id: string;
+    readonly stage: string;
+    readonly discovered: boolean;
+    readonly name: string;
+};
+export type DexViewModel = {
+    readonly kind: "available";
+    readonly rows: readonly DexRow[];
+} | {
+    readonly kind: "empty";
+} | {
+    readonly kind: "unavailable";
+    readonly message: string;
+};
+export declare const buildDexViewModel: (archive: DigitalPetArchiveResult, catalog: DigimonCatalog, settings: ResolvedDigitalPetSettings) => DexViewModel;

package/dist/digital-pet-core/view-models/history-view-model.d.ts

@@ -0,0 +1,20 @@
+import type { DigitalPetArchiveResult } from "../application/models/digital-pet-archive.js";
+import type { ResolvedDigitalPetSettings } from "../config/types.js";
+import type { DigimonCatalog } from "../data/catalog.js";
+export type HistoryGeneration = {
+    readonly partnerId: string;
+    readonly generation: number;
+    readonly createdAt: string;
+    readonly retiredAt: string | null;
+    readonly path: readonly string[];
+};
+export type HistoryViewModel = {
+    readonly kind: "available";
+    readonly generations: readonly HistoryGeneration[];
+} | {
+    readonly kind: "empty";
+} | {
+    readonly kind: "unavailable";
+    readonly message: string;
+};
+export declare const buildHistoryViewModel: (archive: DigitalPetArchiveResult, catalog: DigimonCatalog, settings: ResolvedDigitalPetSettings) => HistoryViewModel;

package/dist/digital-pet-core/view-models/sidebar-view-model.d.ts

@@ -0,0 +1,20 @@
+import type { SidebarCardInputs } from "../application/models/sidebar-card-inputs.js";
+import type { ResolvedDigitalPetSettings } from "../config/types.js";
+export type SidebarCardModel = {
+    readonly kind: "no_partner";
+    readonly messageLine: string;
+} | {
+    readonly kind: "partner";
+    readonly name: string;
+    readonly sprite: string;
+    readonly stage: string;
+    readonly stageNumber: number;
+    readonly url: string;
+    readonly gauge: number;
+    readonly threshold: number;
+    readonly isTerminal: boolean;
+    readonly frozen: boolean;
+    readonly isSetOverride: boolean;
+    readonly evolutionBattlePending: boolean;
+};
+export declare const buildSidebarCardModel: (inputs: SidebarCardInputs, settings?: ResolvedDigitalPetSettings) => SidebarCardModel;

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export { createCommandConfig } from "./adapters/opencode/create-server-hooks.js";
+export { DIGIMON_DATA } from "./digital-pet-core/data/digimon-data.js";
+export type { DigimonId, DigimonRecord, DigimonStage } from "./digital-pet-core/data/digimon-data.js";
+export declare const plugin: Plugin;
+declare const entryPlugin: {
+    readonly id: "opencode-digital-pet";
+    readonly server: Plugin;
+};
+export default entryPlugin;