@sbugallo/pokecode 0.0.0 → 0.2.1

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,sCAAsC,CAAA"}

package/dist/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@sbugallo/pokecode-local",
+  "private": true,
+  "type": "module",
+  "main": "./index.js",
+  "exports": {
+    ".": "./index.js",
+    "./tui": "./tui.js"
+  }
+}

package/dist/rpc.d.ts

@@ -0,0 +1,2 @@
+export { PokecodeRpc } from "./adapters/opencode/rpc/contract.js";
+//# sourceMappingURL=rpc.d.ts.map

package/dist/rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../src/rpc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,qCAAqC,CAAA"}

package/dist/rpc.js

@@ -0,0 +1,568 @@
+// @bun
+// src/adapters/opencode/rpc/contract.ts
+import { Rpc } from "@opencode/plugin/rpc";
+
+// src/application/contracts/game.ts
+import { z as z8 } from "zod";
+
+// src/domain/encounters/encounter.ts
+import { z as z3 } from "zod";
+
+// src/domain/pokemon/types.ts
+import { z } from "zod";
+var moveSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1)
+});
+var ivsSchema = z.object({
+  hp: z.number().int().min(0).max(31),
+  attack: z.number().int().min(0).max(31),
+  defense: z.number().int().min(0).max(31),
+  specialAttack: z.number().int().min(0).max(31),
+  specialDefense: z.number().int().min(0).max(31),
+  speed: z.number().int().min(0).max(31)
+});
+var evsSchema = z.object({
+  hp: z.literal(0),
+  attack: z.literal(0),
+  defense: z.literal(0),
+  specialAttack: z.literal(0),
+  specialDefense: z.literal(0),
+  speed: z.literal(0)
+});
+var pokemonGenderSchema = z.enum(["male", "female", "genderless"]);
+var availablePokemonGendersSchema = z.array(z.enum(["male", "female", "unknown"])).min(1).max(2).refine((genders) => new Set(genders).size === genders.length, "Genders must be unique").refine((genders) => !genders.includes("unknown") || genders.length === 1, "Unknown cannot be combined with male or female");
+
+// src/domain/shared/identifiers.ts
+import { z as z2 } from "zod";
+var pokemonIdSchema = z2.string().uuid().brand();
+var trainerIdSchema = z2.string().uuid().brand();
+var regionIdSchema = z2.string().min(1).brand();
+var locationIdSchema = z2.string().min(1).brand();
+var speciesIdSchema = z2.string().min(1).brand();
+
+// src/domain/encounters/encounter.ts
+var encounterKindSchema = z3.enum(["ordinary", "special"]);
+var pendingEncounterSchema = z3.object({
+  id: z3.string().uuid(),
+  kind: encounterKindSchema,
+  speciesId: speciesIdSchema,
+  name: z3.string().min(1),
+  level: z3.number().int().min(1).max(100),
+  gender: pokemonGenderSchema,
+  shiny: z3.boolean(),
+  spriteUrl: z3.string().url()
+});
+function randomInteger(minimum, maximum, random) {
+  return minimum + Math.min(Math.floor(random() * (maximum - minimum + 1)), maximum - minimum);
+}
+function randomEncounterInterval(minimumTokens, maximumTokens, random) {
+  return randomInteger(minimumTokens, maximumTokens, random);
+}
+function selectWeightedEncounter(candidates, random) {
+  const totalWeight = candidates.reduce((total, candidate) => total + candidate.weight, 0);
+  if (totalWeight === 0)
+    return null;
+  let remaining = random() * totalWeight;
+  for (const candidate of candidates) {
+    remaining -= candidate.weight;
+    if (remaining < 0)
+      return candidate;
+  }
+  return candidates.at(-1) ?? null;
+}
+function selectSpecialEncounter(candidates, random) {
+  const roll = candidates.length > 0 ? random() : 1;
+  return roll < candidates.length * 0.01 ? candidates[Math.min(Math.floor(roll * 100), candidates.length - 1)] ?? null : null;
+}
+function eligibleOrdinaryEncounters(candidates, maximumLevel) {
+  return candidates.filter((candidate) => candidate.minimumLevel <= maximumLevel).map((candidate) => ({
+    ...candidate,
+    maximumLevel: Math.min(candidate.maximumLevel, maximumLevel)
+  }));
+}
+function eligibleSpecialEncounters(candidates, maximumLevel, alreadyTriggered) {
+  return candidates.filter((candidate) => candidate.minimumLevel <= maximumLevel && !alreadyTriggered.has(candidate.specialEncounterId));
+}
+function generateEncounterAttributes(minimumLevel, maximumLevel, availableGenders, random) {
+  if (availableGenders.length === 0)
+    throw new Error("Encounter species has no available genders");
+  const level = randomInteger(minimumLevel, maximumLevel, random);
+  const selectedGender = availableGenders[randomInteger(0, availableGenders.length - 1, random)];
+  if (selectedGender === undefined)
+    throw new Error("Invalid encounter gender selection");
+  const gender = selectedGender === "unknown" ? "genderless" : selectedGender;
+  const shiny = random() < 1 / 4096;
+  return { level, gender, shiny };
+}
+function generateCapturedAttributes(random, natures) {
+  const natureIndex = randomInteger(0, natures.length - 1, random);
+  const nature = natures[natureIndex] ?? "Hardy";
+  const ivs = [
+    randomInteger(0, 31, random),
+    randomInteger(0, 31, random),
+    randomInteger(0, 31, random),
+    randomInteger(0, 31, random),
+    randomInteger(0, 31, random),
+    randomInteger(0, 31, random)
+  ];
+  return { nature, ivs };
+}
+
+// src/domain/exploration/exploration.ts
+import { z as z4 } from "zod";
+var locationStatusSchema = z4.object({
+  id: locationIdSchema,
+  name: z4.string().min(1),
+  unlocked: z4.boolean(),
+  encounterless: z4.boolean()
+});
+var explorationStatusSchema = z4.object({
+  regions: z4.array(z4.object({
+    id: z4.string().min(1),
+    name: z4.string().min(1),
+    visited: z4.boolean(),
+    completed: z4.boolean(),
+    locations: z4.array(locationStatusSchema)
+  })).default([]),
+  locations: z4.array(locationStatusSchema).min(1),
+  locationUnlockProgress: z4.number().int().nonnegative(),
+  locationUnlockThreshold: z4.number().int().positive(),
+  regionComplete: z4.boolean()
+});
+function calculateUnlockProgress(input) {
+  if (!input.currentLocationIsLatestUnlocked)
+    return { kind: "not-latest" };
+  if (!input.hasNextLocation)
+    return { kind: "complete-region", tokenCount: input.currentTokens };
+  const tokenCount = input.currentTokens + input.gainedTokens;
+  return tokenCount < input.threshold ? { kind: "accumulating", tokenCount } : { kind: "unlock", tokenCount: 0 };
+}
+function locationTravelEligibility(input) {
+  if (!input.locationExists)
+    return "invalid-location";
+  return input.unlocked ? "allowed" : "locked-location";
+}
+function regionTravelEligibility(input) {
+  if (!input.regionExists)
+    return "invalid-region";
+  if (!input.currentRegionComplete)
+    return "region-incomplete";
+  if (input.targetAlreadyVisited)
+    return "already-visited";
+  return "allowed";
+}
+
+// src/domain/party/party.ts
+import { z as z6 } from "zod";
+
+// src/domain/pokemon/model.ts
+import { z as z5 } from "zod";
+var pokemonInstanceSchema = z5.object({
+  id: pokemonIdSchema,
+  speciesId: speciesIdSchema,
+  name: z5.string().min(1),
+  gender: pokemonGenderSchema.default("genderless"),
+  level: z5.number().int().min(1).max(100),
+  experience: z5.number().nonnegative(),
+  ability: z5.string().min(1),
+  nature: z5.string().min(1),
+  shiny: z5.boolean(),
+  ivs: ivsSchema,
+  evs: evsSchema,
+  moves: z5.array(moveSchema).max(4)
+});
+
+// src/domain/party/party.ts
+var partySlotSchema = z6.object({
+  position: z6.number().int().min(1).max(6),
+  pokemon: pokemonInstanceSchema.nullable()
+});
+function validatePartyReplacement(facts) {
+  const maximumSize = facts.maximumSize ?? 6;
+  if (facts.pokemonIds.length === 0)
+    return { valid: false, reason: "empty" };
+  if (facts.pokemonIds.length > maximumSize)
+    return { valid: false, reason: "too-large" };
+  if (new Set(facts.pokemonIds).size !== facts.pokemonIds.length)
+    return { valid: false, reason: "duplicate" };
+  if (facts.ownedPokemonCount !== undefined && facts.ownedPokemonCount !== facts.pokemonIds.length)
+    return { valid: false, reason: "not-owned" };
+  return { valid: true, pokemonIds: facts.pokemonIds };
+}
+
+// src/domain/shared/language.ts
+import { z as z7 } from "zod";
+var languageSchema = z7.enum(["en", "es"]).default("en");
+
+// src/application/contracts/game.ts
+var pendingChoiceSchema = z8.object({
+  id: z8.string().uuid(),
+  kind: z8.string().min(1),
+  payload: z8.string()
+});
+var gameStateSchema = z8.object({
+  phase: z8.enum(["onboarding", "active"]),
+  locale: languageSchema,
+  message: z8.string(),
+  region: z8.string().nullable(),
+  location: z8.string().nullable(),
+  party: z8.array(partySlotSchema).length(6),
+  pendingChoices: z8.array(pendingChoiceSchema),
+  pendingEncounterCount: z8.number().int().nonnegative().default(0),
+  choicePokemon: z8.array(pokemonInstanceSchema).default([]),
+  pendingEncounter: pendingEncounterSchema.extend({ caught: z8.boolean().default(false) }).nullable().default(null),
+  exploration: explorationStatusSchema.nullable().default(null)
+});
+var starterChoiceInputSchema = z8.object({
+  regionId: z8.string().min(1),
+  speciesId: z8.string().min(1)
+});
+var starterChoiceResultSchema = z8.object({
+  kind: z8.enum(["selected", "invalid-region", "invalid-starter", "already-selected"]),
+  state: gameStateSchema
+});
+var gameplayConfigSchema = z8.object({
+  pauseOnPendingChoice: z8.boolean().default(true),
+  xpTokensPerPoint: z8.number().int().positive().default(1000),
+  encounterMinimumTokens: z8.number().int().positive().default(200000),
+  encounterMaximumTokens: z8.number().int().positive().default(400000),
+  locationUnlockTokens: z8.number().int().positive().default(2160000)
+});
+var usageInputSchema = z8.object({
+  sessionId: z8.string().min(1),
+  messageId: z8.string().min(1),
+  inputTokens: z8.number().int().nonnegative(),
+  outputTokens: z8.number().int().nonnegative(),
+  reasoningTokens: z8.number().int().nonnegative(),
+  cacheReadTokens: z8.number().int().nonnegative(),
+  cacheWriteTokens: z8.number().int().nonnegative(),
+  completedAt: z8.string().datetime()
+});
+var usageApplicationSchema = z8.object({
+  kind: z8.enum(["applied", "duplicate", "frozen-discarded", "inactive"]),
+  state: gameStateSchema
+});
+var locationTravelInputSchema = z8.object({ locationId: z8.string().min(1) });
+var locationTravelResultSchema = z8.object({
+  kind: z8.enum(["teleported", "inactive", "invalid-location", "locked-location"]),
+  state: gameStateSchema
+});
+var regionTravelInputSchema = z8.object({ regionId: z8.string().min(1) });
+var regionTravelResultSchema = z8.object({
+  kind: z8.enum(["traveled", "inactive", "invalid-region", "already-visited", "region-incomplete"]),
+  state: gameStateSchema
+});
+var encounterResolutionResultSchema = z8.object({
+  kind: z8.enum(["caught", "ran", "inactive", "no-encounter"]),
+  state: gameStateSchema
+});
+var partyReplacementInputSchema = z8.object({
+  pokemonIds: z8.array(z8.string().uuid()).min(1).max(6)
+});
+var partyReplacementResultSchema = z8.object({
+  kind: z8.enum(["replaced", "inactive", "invalid-party"]),
+  state: gameStateSchema
+});
+var pokemonRenameInputSchema = z8.object({
+  pokemonId: z8.string().uuid(),
+  name: z8.string()
+});
+var pokemonReleaseInputSchema = z8.object({ pokemonId: z8.string().uuid() });
+var pokemonManagementResultSchema = z8.object({
+  kind: z8.enum([
+    "renamed",
+    "released",
+    "inactive",
+    "invalid-pokemon",
+    "invalid-name",
+    "last-party-pokemon"
+  ]),
+  state: gameStateSchema
+});
+var moveChoiceInputSchema = z8.object({
+  choiceId: z8.string().uuid(),
+  selectedMoveId: z8.string().min(1)
+});
+var evolutionChoiceInputSchema = z8.object({
+  choiceId: z8.string().uuid(),
+  selectedSpeciesId: z8.string().min(1)
+});
+var choiceResolutionResultSchema = z8.object({
+  kind: z8.enum(["resolved", "inactive", "invalid-choice"]),
+  state: gameStateSchema
+});
+var pokemonCollectionSchema = z8.object({ pokemon: z8.array(pokemonInstanceSchema) });
+var pokedexEntrySchema = z8.object({
+  number: z8.number().int().positive(),
+  speciesId: speciesIdSchema,
+  name: z8.string().min(1),
+  status: z8.enum(["caught", "seen", "unknown"])
+});
+var pokemonDexSchema = z8.object({
+  pokemon: z8.array(pokedexEntrySchema),
+  discoveries: z8.array(z8.object({
+    speciesId: speciesIdSchema,
+    status: z8.enum(["caught", "seen"])
+  }))
+});
+var teamExportSchema = z8.object({
+  kind: z8.enum(["exported", "inactive"]),
+  text: z8.string()
+});
+
+// src/adapters/opencode/rpc/contract.ts
+var emptyObjectInputSchema = {
+  type: "object",
+  properties: {},
+  additionalProperties: false
+};
+var gameStateSchema2 = {
+  type: "object",
+  properties: {
+    phase: { enum: ["onboarding", "active"] },
+    locale: { type: "string", minLength: 2 },
+    message: { type: "string" },
+    region: { type: ["string", "null"] },
+    location: { type: ["string", "null"] },
+    party: { type: "array" },
+    pendingChoices: { type: "array" },
+    pendingEncounter: { type: ["object", "null"] },
+    pendingEncounterCount: { type: "integer", minimum: 0 },
+    choicePokemon: { type: "array" },
+    exploration: { type: ["object", "null"] }
+  },
+  required: [
+    "phase",
+    "locale",
+    "message",
+    "region",
+    "location",
+    "party",
+    "pendingChoices",
+    "pendingEncounter",
+    "pendingEncounterCount",
+    "choicePokemon",
+    "exploration"
+  ],
+  additionalProperties: false
+};
+var encounterResolutionOutputSchema = {
+  type: "object",
+  properties: {
+    kind: { enum: ["caught", "ran", "inactive", "no-encounter"] },
+    state: { type: "object" }
+  },
+  required: ["kind", "state"],
+  additionalProperties: false
+};
+var choiceResolutionOutputSchema = {
+  type: "object",
+  properties: {
+    kind: { enum: ["resolved", "inactive", "invalid-choice"] },
+    state: { type: "object" }
+  },
+  required: ["kind", "state"],
+  additionalProperties: false
+};
+var pokemonListOutputSchema = {
+  type: "object",
+  properties: { pokemon: { type: "array" } },
+  required: ["pokemon"],
+  additionalProperties: false
+};
+var encounterResolutionInputSchema = {
+  type: "object",
+  properties: { encounterId: { type: "string", format: "uuid" } },
+  required: ["encounterId"],
+  additionalProperties: false
+};
+var PokecodeRpc = Rpc.define({
+  id: "pokecode",
+  methods: {
+    status: {
+      input: emptyObjectInputSchema,
+      output: gameStateSchema2
+    },
+    chooseStarter: {
+      input: {
+        type: "object",
+        properties: {
+          regionId: { type: "string", minLength: 1 },
+          speciesId: { type: "string", minLength: 1 }
+        },
+        required: ["regionId", "speciesId"],
+        additionalProperties: false
+      },
+      output: {
+        type: "object",
+        properties: {
+          kind: {
+            enum: ["selected", "invalid-region", "invalid-starter", "already-selected"]
+          },
+          state: { type: "object" }
+        },
+        required: ["kind", "state"],
+        additionalProperties: false
+      }
+    },
+    travelTo: {
+      input: {
+        type: "object",
+        properties: { locationId: { type: "string", minLength: 1 } },
+        required: ["locationId"],
+        additionalProperties: false
+      },
+      output: {
+        type: "object",
+        properties: {
+          kind: { enum: ["teleported", "inactive", "invalid-location", "locked-location"] },
+          state: { type: "object" }
+        },
+        required: ["kind", "state"],
+        additionalProperties: false
+      }
+    },
+    travelToRegion: {
+      input: {
+        type: "object",
+        properties: { regionId: { type: "string", minLength: 1 } },
+        required: ["regionId"],
+        additionalProperties: false
+      },
+      output: {
+        type: "object",
+        properties: {
+          kind: {
+            enum: [
+              "traveled",
+              "inactive",
+              "invalid-region",
+              "already-visited",
+              "region-incomplete"
+            ]
+          },
+          state: { type: "object" }
+        },
+        required: ["kind", "state"],
+        additionalProperties: false
+      }
+    },
+    catchEncounter: {
+      input: encounterResolutionInputSchema,
+      output: encounterResolutionOutputSchema
+    },
+    runEncounter: {
+      input: encounterResolutionInputSchema,
+      output: encounterResolutionOutputSchema
+    },
+    collection: {
+      input: emptyObjectInputSchema,
+      output: pokemonListOutputSchema
+    },
+    dex: {
+      input: emptyObjectInputSchema,
+      output: pokemonDexSchema
+    },
+    exportTeam: {
+      input: emptyObjectInputSchema,
+      output: {
+        type: "object",
+        properties: {
+          kind: { enum: ["exported", "inactive"] },
+          text: { type: "string" }
+        },
+        required: ["kind", "text"],
+        additionalProperties: false
+      }
+    },
+    sprite: {
+      input: {
+        type: "object",
+        properties: {
+          speciesId: { type: "string", minLength: 1 },
+          shiny: { type: "boolean" },
+          gender: { enum: ["male", "female", "genderless"] }
+        },
+        required: ["speciesId", "shiny", "gender"],
+        additionalProperties: false
+      },
+      output: {
+        type: "object",
+        properties: {
+          kind: { enum: ["cached", "placeholder"] },
+          source: { type: "string" }
+        },
+        required: ["kind"],
+        additionalProperties: false
+      }
+    },
+    replaceParty: {
+      input: {
+        type: "object",
+        properties: {
+          pokemonIds: { type: "array", minItems: 1, maxItems: 6, items: { type: "string" } }
+        },
+        required: ["pokemonIds"],
+        additionalProperties: false
+      },
+      output: {
+        type: "object",
+        properties: {
+          kind: { enum: ["replaced", "inactive", "invalid-party"] },
+          state: { type: "object" }
+        },
+        required: ["kind", "state"],
+        additionalProperties: false
+      }
+    },
+    renamePokemon: {
+      input: pokemonRenameInputSchema,
+      output: pokemonManagementResultSchema
+    },
+    releasePokemon: {
+      input: pokemonReleaseInputSchema,
+      output: pokemonManagementResultSchema
+    },
+    resolveMoveChoice: {
+      input: {
+        type: "object",
+        properties: {
+          choiceId: { type: "string" },
+          selectedMoveId: { type: "string", minLength: 1 }
+        },
+        required: ["choiceId", "selectedMoveId"],
+        additionalProperties: false
+      },
+      output: choiceResolutionOutputSchema
+    },
+    resolveEvolutionChoice: {
+      input: {
+        type: "object",
+        properties: {
+          choiceId: { type: "string" },
+          selectedSpeciesId: { type: "string", minLength: 1 }
+        },
+        required: ["choiceId", "selectedSpeciesId"],
+        additionalProperties: false
+      },
+      output: choiceResolutionOutputSchema
+    },
+    dismissNextRegionChoice: {
+      input: emptyObjectInputSchema,
+      output: gameStateSchema2
+    },
+    reopenNextRegionChoice: {
+      input: emptyObjectInputSchema,
+      output: gameStateSchema2
+    }
+  },
+  events: {
+    statusChanged: {
+      schema: gameStateSchema2
+    }
+  }
+});
+export {
+  PokecodeRpc
+};

package/dist/rpc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.js","sourceRoot":"","sources":["../src/rpc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,qCAAqC,CAAA"}

package/dist/tui.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./adapters/opencode/tui/plugin.js";
+//# sourceMappingURL=tui.d.ts.map

package/dist/tui.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tui.d.ts","sourceRoot":"","sources":["../src/tui.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mCAAmC,CAAA"}