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

package/dist/adapters/opencode/create-server-hooks.d.ts

@@ -0,0 +1,38 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import type { DigitalPetLanguage } from "../../digital-pet-core/config/types.js";
+import type { DigimonCatalog } from "../../digital-pet-core/data/catalog.js";
+import type { PartnerLifecycle } from "../../digital-pet-core/application/ports/partner-lifecycle.js";
+import type { UsageLedger } from "../../digital-pet-core/application/ports/usage-ledger.js";
+import type { DigitalPetControl } from "../../digital-pet-core/application/ports/digital-pet-control.js";
+import { type EvolutionSelector, type StageThresholds } from "../../digital-pet-core/domain/evolution.js";
+import type { SessionMessagesFetcher } from "./session-messages.js";
+import { type DigitalPetToastNotifier } from "./digital-pet-toast.js";
+export type ServerResource = {
+    close(): Promise<void>;
+};
+export type ServerHookDependencies = {
+    readonly repository: PartnerLifecycle & UsageLedger & DigitalPetControl;
+    readonly resource: ServerResource;
+    readonly evolutionSelector?: EvolutionSelector;
+    readonly evolutionThresholds?: StageThresholds;
+    readonly fetchMessages?: SessionMessagesFetcher;
+    readonly language?: DigitalPetLanguage;
+    readonly notificationsEnabled?: boolean;
+    readonly loadCatalog?: () => Promise<DigimonCatalog>;
+    readonly notify?: DigitalPetToastNotifier;
+};
+export declare const createCommandConfig: () => {
+    "digital-pet-spawn": {
+        template: string;
+    };
+    "digital-pet-freeze": {
+        template: string;
+    };
+    "digital-pet-unfreeze": {
+        template: string;
+    };
+    "digital-pet-set": {
+        template: string;
+    };
+};
+export declare const createServerHooks: ({ repository, resource, evolutionSelector, evolutionThresholds, fetchMessages, language, notificationsEnabled, loadCatalog, notify, }: ServerHookDependencies) => Hooks;

package/dist/adapters/opencode/digital-pet-toast.d.ts

@@ -0,0 +1,33 @@
+import type { DigitalPetLanguage } from "../../digital-pet-core/config/types.js";
+import type { DigimonCatalog } from "../../digital-pet-core/data/catalog.js";
+export type DigitalPetToastPayload = Readonly<{
+    readonly title: string;
+    readonly message: string;
+    readonly variant: "info" | "success";
+    readonly duration: number;
+}>;
+export type DigitalPetToastEvent = Readonly<{
+    readonly kind: "spawn";
+    readonly nodeId: string;
+    readonly generation: number;
+}> | Readonly<{
+    readonly kind: "freeze";
+}> | Readonly<{
+    readonly kind: "unfreeze";
+}> | Readonly<{
+    readonly kind: "set";
+    readonly nodeId: string;
+}> | Readonly<{
+    readonly kind: "evolution";
+    readonly fromNodeId: string;
+    readonly toNodeId: string;
+}> | Readonly<{
+    readonly kind: "evolution_battle";
+    readonly opponentNodeId: string;
+}> | Readonly<{
+    readonly kind: "defeat";
+}>;
+export type DigitalPetToastNotifier = (payload: DigitalPetToastPayload) => Promise<void>;
+export type DigitalPetToastTransport = (payload: DigitalPetToastPayload) => boolean | Promise<boolean>;
+export declare const formatDigitalPetToast: (event: DigitalPetToastEvent, language: DigitalPetLanguage, catalog: DigimonCatalog) => DigitalPetToastPayload | undefined;
+export declare const createBestEffortDigitalPetToastNotifier: (transport: DigitalPetToastTransport) => DigitalPetToastNotifier;

package/dist/adapters/opencode/session-messages.d.ts

@@ -0,0 +1,14 @@
+import type { Message, SessionMessagesResponse } from "@opencode-ai/sdk";
+export type SessionMessagesFetcher = (sessionID: string) => Promise<readonly Message[]>;
+export type SessionMessagesClient = {
+    readonly session: {
+        messages: (options: {
+            readonly path: {
+                readonly id: string;
+            };
+        }) => Promise<{
+            readonly data: SessionMessagesResponse | undefined;
+        }>;
+    };
+};
+export declare const createSessionMessagesFetcher: (client: SessionMessagesClient) => SessionMessagesFetcher;

package/dist/adapters/opencode/usage-event-mapper.d.ts

@@ -0,0 +1,4 @@
+import type { Event, Message } from "@opencode-ai/sdk";
+import type { CompletedUsage } from "../../digital-pet-core/application/use-cases/record-usage.js";
+export declare const toCompletedUsageFromMessage: (message: Message) => CompletedUsage | null;
+export declare const toCompletedUsageFromEvent: (event: Event) => CompletedUsage | null;

package/dist/adapters/sqlite/bun-sqlite-driver.d.ts

@@ -0,0 +1,6 @@
+import { Database } from "bun:sqlite";
+import type { SqliteExecutor } from "../../digital-pet-core/ports/sqlite-executor.js";
+export type { QueryValue, SqliteExecutor } from "../../digital-pet-core/ports/sqlite-executor.js";
+export declare const createExecutor: (database: Database) => SqliteExecutor;
+export declare const openWritableDatabase: (databasePath: string) => Database;
+export declare const openReadonlyDatabase: (databasePath: string) => Database;

package/dist/adapters/sqlite/sqlite-digital-pet-archive-reader.d.ts

@@ -0,0 +1,11 @@
+import { SQLiteError } from "bun:sqlite";
+import type { DigitalPetArchiveResult } from "../../digital-pet-core/application/models/digital-pet-archive.js";
+import type { DigitalPetArchiveReader } from "../../digital-pet-core/application/ports/digital-pet-archive.js";
+import { type HostPathOptions } from "../../digital-pet-core/adapters/sqlite/app-data-path.js";
+import { type SqliteExecutor } from "./bun-sqlite-driver.js";
+export type CreateSqliteDigitalPetArchiveReaderOptions = HostPathOptions & {
+    readonly databasePath?: string;
+};
+export declare const isRecoverableSqliteReadError: (error: unknown) => error is SQLiteError;
+export declare const readSqliteDigitalPetArchive: (executor: Pick<SqliteExecutor, "all">, close: () => void) => DigitalPetArchiveResult;
+export declare const createSqliteDigitalPetArchiveReader: (options?: CreateSqliteDigitalPetArchiveReaderOptions) => DigitalPetArchiveReader;

package/dist/adapters/sqlite/sqlite-digital-pet-write-store.d.ts

@@ -0,0 +1,11 @@
+import type { SqliteDigitalPetWriteStore } from "../../digital-pet-core/adapters/sqlite/sqlite-digital-pet-types.js";
+import { resolveHostDatabasePath, type HostPathOptions } from "../../digital-pet-core/adapters/sqlite/app-data-path.js";
+import type { SidebarSnapshotReader } from "../../digital-pet-core/application/ports/sidebar-snapshot.js";
+export type CreateSqliteDigitalPetRepositoryOptions = HostPathOptions & {
+    readonly databasePath?: string;
+};
+export { resolveHostDatabasePath };
+export type { HostPathOptions } from "../../digital-pet-core/adapters/sqlite/app-data-path.js";
+export type { PersistedPartnerEvent, SqliteDigitalPetWriteStore, } from "../../digital-pet-core/adapters/sqlite/sqlite-digital-pet-types.js";
+export type OpencodeSqliteDigitalPetRepository = SqliteDigitalPetWriteStore & SidebarSnapshotReader;
+export declare const createSqliteDigitalPetRepository: (options?: CreateSqliteDigitalPetRepositoryOptions) => Promise<OpencodeSqliteDigitalPetRepository>;

package/dist/adapters/sqlite/sqlite-sidebar-snapshot-reader.d.ts

@@ -0,0 +1,8 @@
+import type { SidebarSnapshot, SidebarSnapshotReader } from "../../digital-pet-core/application/ports/sidebar-snapshot.js";
+import { type HostPathOptions } from "../../digital-pet-core/adapters/sqlite/app-data-path.js";
+import type { SqliteExecutor } from "../../digital-pet-core/ports/sqlite-executor.js";
+export type CreateSqliteSidebarSnapshotReaderOptions = HostPathOptions & {
+    readonly databasePath?: string;
+};
+export declare const readSidebarSnapshotFromExecutor: (executor: Pick<SqliteExecutor, "get">) => SidebarSnapshot | null;
+export declare const createSqliteSidebarSnapshotReader: (options?: CreateSqliteSidebarSnapshotReaderOptions) => SidebarSnapshotReader;

package/dist/cli/install.d.ts

@@ -0,0 +1,8 @@
+export declare class OpenCodePluginInstallError extends Error {
+    readonly exitCode: number | null;
+    readonly name = "OpenCodePluginInstallError";
+    constructor(exitCode: number | null);
+}
+export type CommandExecutor = (command: string, arguments_: readonly string[]) => Promise<void>;
+export declare const runCommand: CommandExecutor;
+export declare const installGlobalPlugin: (packageSpec: string, execute?: CommandExecutor) => Promise<void>;

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFile } from "node:fs/promises";
+
+// src/cli/install.ts
+import { spawn } from "node:child_process";
+var OpenCodePluginInstallError = class extends Error {
+  constructor(exitCode) {
+    super(
+      exitCode === null ? "OpenCode plugin installer exited without a status." : `OpenCode plugin installer exited with status ${exitCode}.`
+    );
+    this.exitCode = exitCode;
+  }
+  exitCode;
+  name = "OpenCodePluginInstallError";
+};
+var runCommand = (command, arguments_) => new Promise((resolve, reject) => {
+  const child = spawn(command, arguments_, { shell: false, stdio: "inherit" });
+  child.once("error", reject);
+  child.once("close", (exitCode) => {
+    if (exitCode === 0) resolve();
+    else reject(new OpenCodePluginInstallError(exitCode));
+  });
+});
+var installGlobalPlugin = async (packageSpec, execute = runCommand) => execute("opencode", ["plugin", packageSpec, "--global", "--force"]);
+
+// src/cli.ts
+var HELP = `Usage: opencode-digital-pet <init|update> [--dry-run]
+
+Commands:
+  init       Install the current package version through OpenCode's global plugin installer.
+  update     Reinstall the current package version through the same installer.
+
+Options:
+  --dry-run  Show the native OpenCode command without running it.
+  --help      Show this help text.
+`;
+var EXACT_SEMVER = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+var isPackageManifest = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  if (!("name" in value) || !("version" in value)) return false;
+  const { name, version } = value;
+  return name === "@jcendal/opencode-digital-pet" && typeof version === "string" && EXACT_SEMVER.test(version);
+};
+var readPackageManifest = async () => {
+  const source = await readFile(new URL("../package.json", import.meta.url), "utf8");
+  const manifest = JSON.parse(source);
+  if (!isPackageManifest(manifest)) throw new Error("Invalid opencode-digital-pet package manifest.");
+  return manifest;
+};
+var parseArguments = (arguments_) => {
+  if (arguments_.length === 1 && arguments_[0] === "--help") return { kind: "help" };
+  const [command, ...options] = arguments_;
+  if (command !== "init" && command !== "update") return { kind: "invalid", message: "Expected init or update." };
+  if (options.length === 0) return { kind: "command", command, dryRun: false };
+  if (options.length === 1 && options[0] === "--dry-run") return { kind: "command", command, dryRun: true };
+  return { kind: "invalid", message: "Only --dry-run is supported after a command." };
+};
+var run = async () => {
+  const parsed = parseArguments(process.argv.slice(2));
+  switch (parsed.kind) {
+    case "help":
+      process.stdout.write(HELP);
+      return 0;
+    case "invalid":
+      process.stderr.write(`${parsed.message}
+
+${HELP}`);
+      return 2;
+    case "command": {
+      const manifest = await readPackageManifest();
+      const packageSpec = `${manifest.name}@${manifest.version}`;
+      if (parsed.dryRun) {
+        process.stdout.write(`opencode plugin ${packageSpec} --global --force
+`);
+        return 0;
+      }
+      await installGlobalPlugin(packageSpec);
+      process.stdout.write("OpenCode plugin installation completed. Restart OpenCode.\n");
+      return 0;
+    }
+  }
+};
+run().then((exitCode) => {
+  process.exitCode = exitCode;
+}).catch((error) => {
+  const message = error instanceof Error ? error.message : "Unexpected CLI failure.";
+  process.stderr.write(`${message}
+`);
+  process.exitCode = 1;
+});

package/dist/commands/digital-pet-command-result.d.ts

@@ -0,0 +1,17 @@
+import type { Part } from "@opencode-ai/sdk";
+export type DigitalPetCommandEvent = {
+    readonly kind: "spawned";
+    readonly nodeId: string;
+    readonly generation: number;
+} | {
+    readonly kind: "frozen";
+} | {
+    readonly kind: "unfrozen";
+} | {
+    readonly kind: "set";
+    readonly nodeId: string;
+};
+export type DigitalPetCommandResult = {
+    readonly parts: readonly Part[];
+    readonly event?: DigitalPetCommandEvent;
+};

package/dist/commands/digital-pet-freeze.d.ts

@@ -0,0 +1,7 @@
+import type { DigitalPetControl } from "../digital-pet-core/application/ports/digital-pet-control.js";
+import type { DigitalPetCommandResult } from "./digital-pet-command-result.js";
+export type DigitalPetFreezeContext = {
+    readonly sessionID: string;
+    readonly messageID: string;
+};
+export declare const runDigitalPetFreezeCommand: (control: Pick<DigitalPetControl, "freeze">, context: DigitalPetFreezeContext) => Promise<DigitalPetCommandResult>;

package/dist/commands/digital-pet-set.d.ts

@@ -0,0 +1,10 @@
+import type { DigitalPetControl } from "../digital-pet-core/application/ports/digital-pet-control.js";
+import type { DigimonCatalog } from "../digital-pet-core/data/catalog.js";
+import type { DigitalPetCommandResult } from "./digital-pet-command-result.js";
+export type DigitalPetSetContext = {
+    readonly sessionID: string;
+    readonly messageID: string;
+    readonly arguments: string;
+};
+export type DigimonCatalogLoader = () => Promise<DigimonCatalog>;
+export declare const runDigitalPetSetCommand: (control: Pick<DigitalPetControl, "setCheatNode">, context: DigitalPetSetContext, loadCatalog: DigimonCatalogLoader) => Promise<DigitalPetCommandResult>;

package/dist/commands/digital-pet-spawn.d.ts

@@ -0,0 +1,8 @@
+import type { PartnerLifecycle } from "../digital-pet-core/application/ports/partner-lifecycle.js";
+import type { DigitalPetCommandResult } from "./digital-pet-command-result.js";
+export type DigitalPetSpawnContext = {
+    readonly sessionID: string;
+    readonly messageID: string;
+    readonly createdAt: string;
+};
+export declare const runDigitalPetSpawnCommand: (lifecycle: PartnerLifecycle, context: DigitalPetSpawnContext) => Promise<DigitalPetCommandResult>;

package/dist/commands/digital-pet-unfreeze.d.ts

@@ -0,0 +1,7 @@
+import type { DigitalPetControl } from "../digital-pet-core/application/ports/digital-pet-control.js";
+import type { DigitalPetCommandResult } from "./digital-pet-command-result.js";
+export type DigitalPetUnfreezeContext = {
+    readonly sessionID: string;
+    readonly messageID: string;
+};
+export declare const runDigitalPetUnfreezeCommand: (control: Pick<DigitalPetControl, "unfreeze">, context: DigitalPetUnfreezeContext) => Promise<DigitalPetCommandResult>;

package/dist/config/global-digital-pet-settings.d.ts

@@ -0,0 +1,14 @@
+import type { ResolvedDigitalPetSettings } from "../digital-pet-core/config/types.js";
+type PathApi = Readonly<{
+    join: (...paths: readonly string[]) => string;
+}>;
+export type GlobalDigitalPetConfigOptions = Readonly<{
+    readonly env?: NodeJS.ProcessEnv;
+    readonly home?: string;
+    readonly pathApi?: PathApi;
+    readonly platform?: NodeJS.Platform;
+}>;
+export declare const resolveGlobalDigitalPetConfigPath: (options?: GlobalDigitalPetConfigOptions) => string;
+export declare const loadGlobalDigitalPetSettings: (options?: GlobalDigitalPetConfigOptions) => Promise<ResolvedDigitalPetSettings>;
+export declare const loadGlobalDigitalPetSettingsSync: (options?: GlobalDigitalPetConfigOptions) => ResolvedDigitalPetSettings;
+export {};