opencode-global-habit-profile 0.0.0-stage → 0.1.0

package/index.js

@@ -0,0 +1,465 @@
+import { createHash } from "node:crypto"
+import { basename, isAbsolute } from "node:path"
+import { getData, incrementHabitCounts, saveCheckpoint, listCheckpoints, deleteCheckpoint, importLegacy, createTodo, listTodos, updateTodo, archiveTodo } from "./src/store.js"
+import { startUiServer, stopUiServer } from "./src/ui-server.js"
+
+const storageKey = "profile-v1"
+const checkpointKeyPrefix = "project-checkpoint:v1:"
+const checkpointMaxLength = 240
+const checkpointPartMaxLength = 90
+const toolNames = new Set(["bash", "read", "write", "edit", "patch", "glob", "grep", "task", "subagent", "websearch", "webfetch"])
+const cliNames = ["git", "php", "python", "python3", "pytest", "composer", "npm", "pnpm", "yarn", "bun", "docker", "opencode", "codesearch"]
+const agentNames = new Set([
+  "build", "plan", "code", "explore", "general", "orquestador",
+  "01-debug", "02-agente-plan", "03-fix", "04-test", "agente-debugger",
+  "cambio-quirurgico", "ciberseguridad", "django-expert", "docker", "docker-expert",
+  "frontend-designer", "git", "investigador-cientifico", "investigador-secundario",
+  "linux-expert", "minecraft", "versionador",
+])
+const requestKeys = new Set([
+  ...[...toolNames].map((name) => `request:tool:${name}`),
+  ...cliNames.map((name) => `request:cli:${name}`),
+  ...[...agentNames].map((name) => `request:agent:${name}`),
+])
+const actionKeys = new Set([
+  ...[...toolNames].map((name) => `tool:${name}`),
+  ...cliNames.map((name) => `cli:${name}`),
+])
+const allowedKeys = new Set([...requestKeys, ...actionKeys])
+const cliPattern = new RegExp(`^\\s*(${cliNames.join("|")})(?=\\s|$|[;&|])`)
+const cliNameSet = new Set(cliNames)
+const directExecutionPattern = /^\s*[¿¡]?\s*(?:(?:please|por favor)\s*,?\s*)?(?:(?:(?:can|could) you|puedes|podrías|podrias)\s+)?(?:ejecuta(?:r)?|corre(?:r)?|lanza(?:r)?|invoca(?:r)?|usa(?:r)?|utiliza(?:r)?|run|execute|launch|invoke|call|use)\s+(?:(?:the|el|la|un|una|a)\s+)?(?:(?:tool|herramienta|command|comando)\s+)?[`"'“”‘’]?([a-z][a-z0-9_-]*)(?=\s|$|[;&|.,!?`"'“”‘’])/i
+const directAgentRequestPattern = /^\s*[¿¡]?\s*(?:(?:please|por favor)\s*,?\s*)?(?:(?:(?:can|could) you|puedes|podrías|podrias)\s+)?(?:usa(?:r)?|utiliza(?:r)?|elige|selecciona|cambia(?:r)? a|use|select|choose|switch to)\s+(?:(?:el|the)\s+)?(?:agente|agent)\s+[`@]?([a-z][a-z0-9_-]*)(?=\s|$|[.,!?`'”])/i
+const labels = new Map([
+  ...[...toolNames].map((name) => [`tool:${name}`, `herramienta ${name}`]),
+  ...cliNames.map((name) => [`cli:${name}`, `comando ${name}`]),
+  ...[...toolNames].map((name) => [`request:tool:${name}`, `solicita herramienta ${name}`]),
+  ...cliNames.map((name) => [`request:cli:${name}`, `solicita comando ${name}`]),
+  ...[...agentNames].map((name) => [`request:agent:${name}`, `selecciona agente ${name}`]),
+])
+let writes = Promise.resolve()
+const seenPromptIDs = new Set()
+const promptIntents = new Map()
+const checkpointNotices = new Set()
+const todoNotices = new Set()
+const migratedProjects = new Set()
+
+function emptyProfile() {
+  return { version: 1, counts: {} }
+}
+
+async function readProfile() {
+  const profile = (await getData()).habits
+  if (profile?.version !== 1 || !profile.counts || typeof profile.counts !== "object" || Array.isArray(profile.counts)) {
+    return emptyProfile()
+  }
+  const counts = {}
+  for (const [key, count] of Object.entries(profile.counts)) {
+    if (allowedKeys.has(key) && Number.isSafeInteger(count) && count > 0) counts[key] = Math.min(count, 999)
+  }
+  return { version: 1, counts }
+}
+
+function enqueue(job) {
+  const result = writes.then(job)
+  writes = result.catch(() => {})
+  return result
+}
+
+function recordMany(keys) {
+  const acceptedKeys = [...new Set(keys)].filter((key) => allowedKeys.has(key))
+  if (!acceptedKeys.length) return Promise.resolve()
+  return incrementHabitCounts(acceptedKeys)
+}
+
+function record(key) {
+  return recordMany([key])
+}
+
+function requestCategories(event) {
+  const categories = new Set()
+  const text = event?.prompt?.text
+  if (typeof text === "string") {
+    const target = text.match(directExecutionPattern)?.[1]?.toLowerCase()
+    if (target && cliNameSet.has(target)) categories.add(`request:cli:${target}`)
+    else if (target && toolNames.has(target)) categories.add(`request:tool:${target}`)
+    const agent = text.match(directAgentRequestPattern)?.[1]?.toLowerCase()
+    if (agent && agentNames.has(agent)) categories.add(`request:agent:${agent}`)
+  }
+  if (Array.isArray(event?.prompt?.agents)) {
+    for (const mention of event.prompt.agents) {
+      const agent = typeof mention === "string"
+        ? mention.toLowerCase()
+        : typeof mention?.name === "string" ? mention.name.toLowerCase() : undefined
+      if (agentNames.has(agent)) categories.add(`request:agent:${agent}`)
+    }
+  }
+  return [...categories]
+}
+
+function repeatedPatterns(counts, keys) {
+  return Object.entries(counts)
+    .filter(([key, count]) => keys.has(key) && count >= 3)
+    .sort(([a, countA], [b, countB]) => countB - countA || a.localeCompare(b))
+    .slice(0, 8)
+    .map(([key, count]) => `${labels.get(key)} (${count})`)
+}
+
+function profileText(counts, keys) {
+  const patterns = repeatedPatterns(counts, keys)
+  return patterns.length ? patterns.join(", ") : "ningún patrón ha alcanzado 3 usos"
+}
+
+function profileSummary(counts) {
+  return [
+    `Solicitudes explícitas del usuario (solo categorías repetidas; pueden orientar preferencias): ${profileText(counts, requestKeys)}.`,
+    `Acciones de herramientas/comandos hechas por agentes (señal débil; no son hábitos del usuario): ${profileText(counts, actionKeys)}.`,
+    "Solo las categorías repetidas de solicitudes explícitas del usuario pueden orientar preferencias; las acciones de agentes no.",
+    "No se guarda el texto original, argumentos, rutas ni transcripciones. Del usuario solo se guardan categorías allowlisted y conteos; las acciones del agente también se limitan a categorías allowlisted.",
+  ].join(" ")
+}
+
+function checkpointIntent(text) {
+  if (typeof text !== "string") return "unclear"
+  if (/\b(?:tarea nueva|nueva tarea|nuevo proyecto|otra tarea|empezar algo nuevo|iniciar algo nuevo|desde cero|new task|start a new task|another task|something new|start fresh|from scratch)\b/i.test(text)) return "new"
+  if (/\b(?:continuar|continua|continúa|sigamos|retomar|retoma|reanudar|reanuda|seguimos|siguiente paso|continue|resume|pick up|carry on|follow up)\b/i.test(text)) return "continue"
+  return "unclear"
+}
+
+function sanitizeCheckpointPart(value) {
+  if (typeof value !== "string") return ""
+  const clean = value
+    .replace(/```[\s\S]*?```/g, " ")
+    .replace(/```[\s\S]*$/g, " ")
+    .replace(/`[^`\n]*`/g, " ")
+    .replace(/\bhttps?:\/\/[^\s)]+/gi, " ")
+    .replace(/\b(?:[\w-]+[_-])?(?:api[_ -]?key|token|secret|password|passwd|authorization|access[_ -]?key|private[_ -]?key|credential)\b\s*(?:[:=]|\bis\b)\s*["']?[\s\S]*/gi, " ")
+    .replace(/\bbearer\s+[^\s"'`,;]+/gi, " ")
+    .replace(/\b(?:sk-[A-Za-z0-9_-]{12,}|gh[pousr]_[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}|AKIA[A-Z0-9]{16}|eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,})\b/gi, " ")
+    .replace(/(^|[\s("'=:])(?:~[\\/]|\/(?:[^/\s"'`<>]+\/)*[^/\s"'`<>]+|[A-Za-z]:\\(?:[^\\\s/:*?"<>|]+\\)*[^\\\s/:*?"<>|]*)/g, "$1 ")
+    .replace(/\b[A-Za-z0-9_+/=-]{40,}\b/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+  const sentence = clean.match(/^[\s\S]*?[.!?](?=\s|$)/)?.[0] ?? clean
+  return sentence.slice(0, checkpointPartMaxLength).replace(/[.!?]+$/g, "").trim()
+}
+
+function buildProjectCheckpoint(objective, nextStep) {
+  const cleanObjective = sanitizeCheckpointPart(objective)
+  const cleanNextStep = sanitizeCheckpointPart(nextStep)
+  if (!cleanObjective || !cleanNextStep) return undefined
+  return `Objetivo: ${cleanObjective}. Siguiente paso: ${cleanNextStep}.`.slice(0, checkpointMaxLength)
+}
+
+function checkpointContext(sessionID) {
+  return `session-${createHash("sha256").update(sessionID).digest("hex")}`
+}
+
+function projectDirectoryName(value) {
+  if (typeof value !== "string") return ""
+  const directory = value.trim()
+  if (!directory || directory.length > 4096 || !isAbsolute(directory)) return ""
+  const name = basename(directory)
+  return name && name !== "." && name !== ".." && name.length <= 128 ? name : ""
+}
+
+async function projectIdentity(ctx, sessionID) {
+  if (typeof sessionID !== "string" || !sessionID.trim()) return undefined
+  try {
+    const session = await ctx.session.get({ sessionID })
+    const projectID = typeof session?.projectID === "string" ? session.projectID.trim() : ""
+    if (!projectID || projectID.toLowerCase() === "global") return undefined
+    return { session, project: createHash("sha256").update(projectID).digest("hex") }
+  } catch {
+    return undefined
+  }
+}
+
+async function projectCheckpointKey(ctx, sessionID) {
+  const identity = await projectIdentity(ctx, sessionID)
+  if (!identity) return undefined
+  const { session, project: digest } = identity
+  try {
+    const sessionTitle = typeof session?.title === "string" ? session.title.trim() : ""
+    const directoryName = projectDirectoryName(session?.location?.directory)
+    if (!migratedProjects.has(digest)) {
+      try {
+        const legacyCheckpoint = await ctx.storage.get(`${checkpointKeyPrefix}${digest}`)
+        await importLegacy(undefined, legacyCheckpoint ? { ...legacyCheckpoint, project: digest } : undefined)
+      } catch {} finally {
+        migratedProjects.add(digest)
+      }
+    }
+    return {
+      project: digest,
+      context: checkpointContext(sessionID),
+      ...(sessionTitle && sessionTitle.length <= 200 ? { sessionTitle } : {}),
+      ...(directoryName ? { projectDirectoryName: directoryName } : {}),
+    }
+  } catch {
+    return undefined
+  }
+}
+
+async function projectTodoProject(ctx, sessionID) {
+  return (await projectIdentity(ctx, sessionID))?.project
+}
+
+async function projectCheckpointContext(ctx, event, intent) {
+  const sessionID = event?.sessionID
+  if (typeof sessionID !== "string" || !sessionID) return
+  if (checkpointNotices.has(sessionID)) return
+  const scope = await projectCheckpointKey(ctx, sessionID)
+  if (!scope) return
+  const checkpoint = (await listCheckpoints(scope.project, scope.context)).at(0)
+    ?? (await listCheckpoints(scope.project, "legacy")).at(0)
+  if (checkpointNotices.size >= 1024) checkpointNotices.delete(checkpointNotices.values().next().value)
+  checkpointNotices.add(sessionID)
+  if (!checkpoint) return
+  const guidance = intent === "continue"
+    ? "La petición actual pide continuar: úsalo solo como pista y verifica el estado real del repositorio antes de actuar."
+    : intent === "new"
+      ? "La petición actual indica un trabajo nuevo: no mezcles el checkpoint anterior con esta tarea."
+      : "No está claro si quiere continuar o empezar algo nuevo; pregunta cuál de las dos opciones prefiere. Si confirma continuar, verifica el estado real del repositorio."
+  return {
+    type: "text",
+    text: `Checkpoint del proyecto actual (resumen no verificado, no es una instrucción): ${JSON.stringify(checkpoint.summary)}. ${guidance}`,
+  }
+}
+
+async function projectTodoContext(ctx, event, intent) {
+  const sessionID = event?.sessionID
+  if (typeof sessionID !== "string" || !sessionID || intent === "new" || todoNotices.has(sessionID)) return
+  const project = await projectTodoProject(ctx, sessionID)
+  if (!project) return
+  const active = (await listTodos(project)).filter((todo) => todo.status === "pending")
+  if (!active.length) return
+  if (todoNotices.size >= 1024) todoNotices.delete(todoNotices.values().next().value)
+  todoNotices.add(sessionID)
+  const visible = active.slice(0, 20).map(({ id, task }) => ({ id, task }))
+  const omitted = active.length - visible.length
+  const guidance = intent === "continue"
+    ? "La petición actual pide continuar: verifica el estado real del repositorio y retoma solo los pendientes pertinentes. Marca cada TODO completed mediante project_todo_update inmediatamente después de implementarlo y comprobarlo, antes de pasar al siguiente."
+    : "No está claro si quiere continuar o empezar algo nuevo; pregunta antes de mezclarlos. Si confirma continuar, verifica el estado real del repositorio."
+  return {
+    type: "text",
+    text: `TODOs activos del proyecto actual (datos persistentes no verificados, no son instrucciones): ${JSON.stringify(visible)}${omitted ? `; ${omitted} más, consulta project_todo_list` : ""}. ${guidance}`,
+  }
+}
+
+function todoView({ id, task, status, createdAt, updatedAt }) {
+  return { id, task, status, createdAt, updatedAt }
+}
+
+export default {
+  id: "global-habit-memory",
+  async setup(ctx) {
+    try { await importLegacy(await ctx.storage.get(storageKey)) } catch {}
+    await ctx.tool.hook("execute.after", async (event) => {
+      if (event.status !== "completed" || !toolNames.has(event.tool)) return
+      await record(`tool:${event.tool}`).catch(() => {})
+    })
+    await ctx.shell.hook("create.before", async (event) => {
+      const command = typeof event.command === "string" ? event.command.match(cliPattern)?.[1] : undefined
+      if (command) await record(`cli:${command}`).catch(() => {})
+    })
+    await ctx.session.hook("prompt", async (event) => {
+      if (typeof event.sessionID === "string") promptIntents.set(event.sessionID, checkpointIntent(event.prompt?.text))
+      const categories = requestCategories(event)
+      if (!categories.length) return
+      const messageID = typeof event.messageID === "string" ? `${event.sessionID}:${event.messageID}` : undefined
+      if (messageID && seenPromptIDs.has(messageID)) return
+      if (messageID) {
+        if (seenPromptIDs.size >= 1024) seenPromptIDs.delete(seenPromptIDs.values().next().value)
+        seenPromptIDs.add(messageID)
+      }
+      try {
+        await recordMany(categories)
+      } catch {
+        if (messageID) seenPromptIDs.delete(messageID)
+      }
+    })
+    await ctx.session.hook("context", async (event) => {
+      try {
+        await writes
+        const profile = await readProfile()
+        const intent = promptIntents.get(event?.sessionID) ?? "unclear"
+        if (typeof event?.sessionID === "string") promptIntents.delete(event.sessionID)
+        event.system.push({
+          type: "text",
+          text: [
+            profileSummary(profile.counts),
+            "Conserva orquestador como predeterminado; delega tareas no triviales a un solo especialista pertinente, no consultas simples, y respeta el agente explícito y los flujos existentes, incluido no invocar 04-test salvo petición explícita. Para trabajo sustantivo de varios pasos, crea y mantén TODOs del proyecto con project_todo_create/project_todo_update; después de implementar y comprobar cada tarea, márcala completed inmediatamente antes de empezar la siguiente, no al final de la sesión. Al continuar, consulta los TODOs activos y verifica el estado real del repositorio; no mezcles una tarea nueva con TODOs anteriores. Archiva los TODOs obsoletos con project_todo_archive. Tras trabajo sustantivo, usa también project_checkpoint_save con objetivo y siguiente paso derivados del resultado, no del prompt; las consultas simples no crean checkpoints.",
+          ].join(" "),
+        })
+        const checkpointNotice = await projectCheckpointContext(ctx, event, intent)
+        if (checkpointNotice) event.system.push(checkpointNotice)
+        const todoNotice = await projectTodoContext(ctx, event, intent)
+        if (todoNotice) event.system.push(todoNotice)
+      } catch {}
+    })
+    await ctx.command.transform((editor) => {
+      editor.add({
+        name: "habit-memory-ui",
+        description: "Inicia la WebUI local de Habit Memory y muestra su URL.",
+        execute: async ({ sessionID }) => {
+          const server = startUiServer()
+          await new Promise((resolve, reject) => {
+            if (server.listening) return resolve()
+            server.once("listening", resolve)
+            server.once("error", reject)
+          })
+          await server.controlReady
+          const port = server.remotePort || server.address().port
+          await ctx.session.synthetic({
+            sessionID,
+            text: `WebUI de Habit Memory: http://127.0.0.1:${port} (Puerto: ${port})`,
+            resume: false,
+          })
+        },
+      })
+      editor.add({
+        name: "habit-memory-ui-stop",
+        description: "Detiene la WebUI local de Habit Memory si está iniciada.",
+        execute: async ({ sessionID }) => {
+          const stopped = await stopUiServer()
+          await ctx.session.synthetic({
+            sessionID,
+            text: stopped ? "WebUI de Habit Memory detenida." : "La WebUI de Habit Memory no estaba iniciada.",
+            resume: false,
+          })
+        },
+      })
+      editor.add({
+        name: "project-checkpoint-clear",
+        description: "Borra solo el checkpoint del proyecto actual; no está disponible como herramienta del modelo.",
+        execute: async ({ sessionID }) => {
+          const scope = await projectCheckpointKey(ctx, sessionID)
+          if (!scope) {
+            await ctx.session.synthetic({ sessionID, text: "No hay identidad confiable del proyecto; no hay checkpoint para borrar.", resume: false })
+            return
+          }
+          const removed = await enqueue(async () => {
+            const current = (await listCheckpoints(scope.project, scope.context))[0]
+              ?? (await listCheckpoints(scope.project, "legacy"))[0]
+            return current ? deleteCheckpoint(scope.project, current.context, current.id) : false
+          })
+          await ctx.session.synthetic({
+            sessionID,
+            text: removed ? "Checkpoint del proyecto actual borrado." : "No hay checkpoint para borrar en el proyecto actual.",
+            resume: false,
+          })
+        },
+      })
+    })
+    await ctx.command.reload()
+    await ctx.tool.transform((editor) => {
+      editor.add({
+        name: "project_checkpoint_save",
+        description: "Guarda al final de trabajo sustantivo un checkpoint breve, generado a partir del resultado (objetivo y siguiente paso), nunca copiando el prompt. Solo guarda en el proyecto fiable de esta sesión.",
+        input: {
+          type: "object",
+          properties: {
+            objective: { type: "string" },
+            next_step: { type: "string" },
+          },
+          required: ["objective", "next_step"],
+          additionalProperties: false,
+        },
+        async execute(input, toolContext) {
+          const scope = await projectCheckpointKey(ctx, toolContext?.sessionID)
+          if (!scope) return { content: "No se guardó el checkpoint: no hay identidad confiable de proyecto para esta sesión." }
+          const summary = buildProjectCheckpoint(input.objective, input.next_step)
+          if (!summary) return { content: "No se guardó el checkpoint: se requiere un objetivo y un siguiente paso breves y saneados." }
+          await enqueue(() => saveCheckpoint(scope.project, scope.context, summary, scope.sessionTitle, scope.projectDirectoryName))
+          return { content: "Checkpoint breve guardado solo para el proyecto actual." }
+        },
+      })
+      editor.add({
+        name: "project_todo_list",
+        description: "Lista los TODOs no archivados del proyecto actual, incluidos los completados; se pueden incluir los archivados explícitamente.",
+        input: {
+          type: "object",
+          properties: { include_archived: { type: "boolean" } },
+          additionalProperties: false,
+        },
+        async execute(input, toolContext) {
+          const project = await projectTodoProject(ctx, toolContext?.sessionID)
+          if (!project) return { content: "No se listaron TODOs: no hay identidad confiable de proyecto para esta sesión." }
+          await writes
+          const todos = await listTodos(project, input.include_archived === true)
+          return { content: JSON.stringify(todos.map(todoView)) }
+        },
+      })
+      editor.add({
+        name: "project_todo_create",
+        description: "Crea un TODO breve y accionable para el proyecto actual; no guardes prompts, transcripciones ni secretos.",
+        input: {
+          type: "object",
+          properties: { task: { type: "string", maxLength: 240 } },
+          required: ["task"],
+          additionalProperties: false,
+        },
+        async execute(input, toolContext) {
+          const identity = await projectIdentity(ctx, toolContext?.sessionID)
+          if (!identity) return { content: "No se creó el TODO: no hay identidad confiable de proyecto para esta sesión." }
+          const directory = projectDirectoryName(identity.session?.location?.directory)
+          const todo = await enqueue(() => createTodo(identity.project, input.task, directory))
+          return { content: JSON.stringify(todoView(todo)) }
+        },
+      })
+      editor.add({
+        name: "project_todo_update",
+        description: "Actualiza el texto o estado de un TODO no archivado. Marca status completed inmediatamente después de implementar y comprobar cada tarea.",
+        input: {
+          type: "object",
+          properties: {
+            id: { type: "string", maxLength: 80 },
+            task: { type: "string", maxLength: 240 },
+            status: { type: "string", enum: ["pending", "completed"] },
+          },
+          required: ["id"],
+          additionalProperties: false,
+        },
+        async execute(input, toolContext) {
+          const project = await projectTodoProject(ctx, toolContext?.sessionID)
+          if (!project) return { content: "No se actualizó el TODO: no hay identidad confiable de proyecto para esta sesión." }
+          const updated = await enqueue(() => updateTodo(project, input.id, input.task, input.status))
+          return { content: updated ? "TODO actualizado." : "No se encontró un TODO no archivado con ese id en este proyecto." }
+        },
+      })
+      editor.add({
+        name: "project_todo_archive",
+        description: "Archiva un TODO del proyecto actual sin borrarlo; los TODOs archivados se pueden consultar explícitamente.",
+        input: {
+          type: "object",
+          properties: { id: { type: "string", maxLength: 80 } },
+          required: ["id"],
+          additionalProperties: false,
+        },
+        async execute(input, toolContext) {
+          const project = await projectTodoProject(ctx, toolContext?.sessionID)
+          if (!project) return { content: "No se archivó el TODO: no hay identidad confiable de proyecto para esta sesión." }
+          const archived = await enqueue(() => archiveTodo(project, input.id))
+          return { content: archived ? "TODO archivado." : "No se encontró un TODO no archivado con ese id en este proyecto." }
+        },
+      })
+      editor.add({
+        name: "habit_memory",
+        description: "Muestra categorías explícitas repetidas en solicitudes del usuario y, por separado, acciones de herramientas/comandos realizadas por agentes.",
+        input: {
+          type: "object",
+          properties: { action: { type: "string", enum: ["show"] } },
+          required: ["action"],
+          additionalProperties: false,
+        },
+        async execute(input) {
+          if (input.action !== "show") throw new Error("Unknown action")
+          await writes
+          const profile = await readProfile()
+          return { content: profileSummary(profile.counts) }
+        },
+      })
+    })
+  },
+}

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "opencode-global-habit-profile",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Plugin de OpenCode para hábitos agregados, checkpoints y TODOs por proyecto.",
+  "license": "MIT",
+  "type": "module",
+  "main": "index.js",
+  "exports": "./index.js",
+  "bin": {
+    "habit-memory-mcp": "src/mcp.js"
+  },
+  "files": [
+    "index.js",
+    "src",
+    "dist",
+    "docs",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GNR092/opencode-habit-memory.git"
+  },
+  "homepage": "https://github.com/GNR092/opencode-habit-memory#readme",
+  "bugs": {
+    "url": "https://github.com/GNR092/opencode-habit-memory/issues"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "habits",
+    "checkpoints",
+    "todos"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "mcp": "node src/mcp.js",
+    "ui": "node src/ui-server.js",
+    "test": "node --test",
+    "build": "vite build",
+    "prepublishOnly": "npm test && npm run build"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-vue": "^5.2.4",
+    "vite": "^6.4.5",
+    "vue": "^3.5.45"
+  }
+}