@grindxp/cli 0.1.7 → 0.1.9

package/dist/web/server/assets/sessions-UCWtijHE.js

@@ -0,0 +1,438 @@
+import { T as TSS_SERVER_FUNCTION } from "../server.js";
+import { e as eq, S as companionSettings, T as asc, U as companionInsights, l as sql, d as desc, b as and, N as skills, V as skillSchema, W as skillCategorySchema, X as skillLevelFromXp, Y as inArray, M as quests, _ as questSchema, P as gte, Q as questLogs, $ as completeQuestInputSchema, a0 as calculateQuestXp, B as questDifficultySchema, a1 as proofs, L as users, a2 as levelFromXp, a3 as createQuestInputSchema, a4 as conversations, a5 as promptHistory, a6 as messages } from "./vault.server-CscY5Z8e.js";
+const createServerRpc = (serverFnMeta, splitImportFn) => {
+  const url = "/_serverFn/" + serverFnMeta.id;
+  return Object.assign(splitImportFn, {
+    url,
+    serverFnMeta,
+    [TSS_SERVER_FUNCTION]: true
+  });
+};
+async function getCompanionByUserId(db, userId) {
+  const row = await db.query.companionSettings.findFirst({
+    where: eq(companionSettings.userId, userId)
+  });
+  return row ?? null;
+}
+async function updateCompanionUserContext(db, userId, userContext) {
+  const [updated] = await db.update(companionSettings).set({ userContext, updatedAt: Date.now() }).where(eq(companionSettings.userId, userId)).returning();
+  if (!updated) throw new Error("Companion not found. Run `grindxp init` first.");
+  return updated;
+}
+async function listCompanionInsights(db, userId, limit = 20) {
+  return db.query.companionInsights.findMany({
+    where: eq(companionInsights.userId, userId),
+    orderBy: [
+      asc(sql`case when ${companionInsights.source} = 'user-stated' then 0 else 1 end`),
+      desc(companionInsights.confidence),
+      desc(companionInsights.updatedAt)
+    ],
+    limit
+  });
+}
+async function createCompanionInsight(db, values) {
+  const [row] = await db.insert(companionInsights).values(values).returning();
+  if (!row) throw new Error("Failed to insert companion insight");
+  return row;
+}
+async function updateCompanionInsight(db, insightId, userId, values) {
+  const [row] = await db.update(companionInsights).set({
+    ...values.category !== void 0 ? { category: values.category } : {},
+    ...values.content !== void 0 ? { content: values.content } : {},
+    ...values.confidence !== void 0 ? { confidence: values.confidence } : {},
+    ...values.source !== void 0 ? { source: values.source } : {},
+    updatedAt: Date.now()
+  }).where(and(eq(companionInsights.id, insightId), eq(companionInsights.userId, userId))).returning();
+  if (!row) throw new Error("Companion insight not found");
+  return row;
+}
+async function findCompanionInsightByContent(db, userId, category, content) {
+  const row = await db.query.companionInsights.findFirst({
+    where: and(
+      eq(companionInsights.userId, userId),
+      eq(companionInsights.category, category),
+      sql`lower(trim(${companionInsights.content})) = lower(trim(${content}))`
+    )
+  });
+  return row ?? null;
+}
+async function updateCompanionMode(db, userId, mode) {
+  const [updated] = await db.update(companionSettings).set({ mode, updatedAt: Date.now() }).where(eq(companionSettings.userId, userId)).returning();
+  if (!updated) throw new Error("Companion not found. Run `grindxp init` first.");
+  return updated;
+}
+async function deleteCompanionInsight(db, insightId, userId) {
+  const row = await db.delete(companionInsights).where(and(eq(companionInsights.id, insightId), eq(companionInsights.userId, userId))).returning({ id: companionInsights.id });
+  return row.length > 0;
+}
+function rowToSkill(row) {
+  return skillSchema.parse({
+    id: row.id,
+    userId: row.userId,
+    name: row.name,
+    category: row.category,
+    parentId: row.parentId ?? void 0,
+    xp: row.xp,
+    level: row.level,
+    metadata: row.metadata,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  });
+}
+async function createSkill(db, input) {
+  const [row] = await db.insert(skills).values({
+    userId: input.userId,
+    name: input.name,
+    category: input.category,
+    metadata: {}
+  }).returning();
+  if (!row) throw new Error("Failed to insert skill");
+  return rowToSkill(row);
+}
+async function getSkillByName(db, userId, name) {
+  const row = await db.query.skills.findFirst({
+    where: and(eq(skills.userId, userId), eq(skills.name, name))
+  });
+  if (!row) return null;
+  return rowToSkill(row);
+}
+async function listSkillsByUser(db, userId) {
+  const rows = await db.query.skills.findMany({
+    where: eq(skills.userId, userId),
+    orderBy: [desc(skills.xp)]
+  });
+  return rows.map(rowToSkill);
+}
+async function addXpToSkill(db, skillId, deltaXp) {
+  const row = await db.query.skills.findFirst({ where: eq(skills.id, skillId) });
+  if (!row) throw new Error("Skill not found");
+  const newXp = Math.max(0, row.xp + deltaXp);
+  const newLevel = skillLevelFromXp(newXp);
+  const [updated] = await db.update(skills).set({ xp: newXp, level: newLevel }).where(eq(skills.id, skillId)).returning();
+  if (!updated) throw new Error("Failed to update skill XP");
+  return rowToSkill(updated);
+}
+function parseSkillTag(tag) {
+  const defaultCategory = "life";
+  if (tag.includes(":")) {
+    const [rawCategory, ...rest] = tag.split(":");
+    const name = rest.join(":");
+    const parsed = skillCategorySchema.safeParse(rawCategory);
+    return {
+      name: name || tag,
+      category: parsed.success ? parsed.data : defaultCategory
+    };
+  }
+  return { name: tag, category: defaultCategory };
+}
+async function upsertSkillByTag(db, userId, tag) {
+  const { name, category } = parseSkillTag(tag);
+  const existing = await getSkillByName(db, userId, name);
+  if (existing) return existing;
+  return createSkill(db, { userId, name, category });
+}
+async function distributeSkillXp(db, userId, skillTags, totalXp) {
+  if (skillTags.length === 0 || totalXp <= 0) return [];
+  const xpPerTag = computeXpDistribution(skillTags.length, totalXp);
+  const gains = [];
+  for (let i = 0; i < skillTags.length; i++) {
+    const tag = skillTags[i];
+    const xp = xpPerTag[i];
+    if (tag === void 0 || xp === void 0) continue;
+    const skill = await upsertSkillByTag(db, userId, tag);
+    const xpBefore = skill.xp;
+    const levelBefore = skill.level;
+    const updated = await addXpToSkill(db, skill.id, xp);
+    gains.push({
+      skillId: updated.id,
+      name: updated.name,
+      category: updated.category,
+      xpBefore,
+      xpAfter: updated.xp,
+      levelBefore,
+      levelAfter: updated.level,
+      xpGained: xp,
+      leveledUp: updated.level > levelBefore
+    });
+  }
+  return gains;
+}
+function computeXpDistribution(tagCount, totalXp) {
+  if (tagCount === 1) return [totalXp];
+  const primaryXp = Math.ceil(totalXp * 0.5);
+  const remaining = totalXp - primaryXp;
+  const secondaryCount = tagCount - 1;
+  const perSecondary = Math.floor(remaining / secondaryCount);
+  const distribution = [primaryXp];
+  let distributed = primaryXp;
+  for (let i = 1; i < tagCount; i++) {
+    const xp = i === tagCount - 1 ? totalXp - distributed : perSecondary;
+    distribution.push(xp);
+    distributed += xp;
+  }
+  return distribution;
+}
+function rowToQuest(row) {
+  return questSchema.parse({
+    id: row.id,
+    userId: row.userId,
+    title: row.title,
+    description: row.description ?? void 0,
+    type: row.type,
+    difficulty: row.difficulty,
+    status: row.status,
+    objectives: row.objectives,
+    skillTags: row.skillTags,
+    schedule: row.scheduleCron ? { cron: row.scheduleCron, timezone: "UTC" } : void 0,
+    parentId: row.parentId ?? void 0,
+    streakCount: row.streakCount,
+    baseXp: row.baseXp,
+    metadata: row.metadata,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    completedAt: row.completedAt ?? void 0,
+    deadlineAt: row.deadlineAt ?? void 0
+  });
+}
+async function createQuest(db, input) {
+  const valid = createQuestInputSchema.parse(input);
+  const [row] = await db.insert(quests).values({
+    userId: valid.userId,
+    title: valid.title,
+    description: valid.description,
+    type: valid.type,
+    difficulty: valid.difficulty,
+    status: "active",
+    objectives: valid.objectives,
+    skillTags: valid.skillTags,
+    scheduleCron: valid.schedule?.cron,
+    parentId: valid.parentId,
+    streakCount: valid.streakCount ?? 0,
+    baseXp: valid.baseXp,
+    metadata: valid.metadata,
+    deadlineAt: valid.deadlineAt
+  }).returning();
+  if (!row) throw new Error("Failed to insert quest");
+  return rowToQuest(row);
+}
+async function getQuestById(db, questId) {
+  const row = await db.query.quests.findFirst({ where: eq(quests.id, questId) });
+  if (!row) return null;
+  return rowToQuest(row);
+}
+async function findQuestByPrefix(db, userId, prefix) {
+  const rows = await db.query.quests.findMany({
+    where: eq(quests.userId, userId),
+    orderBy: [desc(quests.updatedAt)]
+  });
+  const lowerPrefix = prefix.toLowerCase();
+  const match = rows.find(
+    (r) => r.id.startsWith(prefix) || r.title.toLowerCase().includes(lowerPrefix)
+  );
+  return match ? rowToQuest(match) : null;
+}
+async function listQuestsByUser(db, userId, statusFilter) {
+  const where = statusFilter?.length ? and(eq(quests.userId, userId), inArray(quests.status, statusFilter)) : eq(quests.userId, userId);
+  const rows = await db.query.quests.findMany({
+    where,
+    orderBy: [desc(quests.updatedAt)]
+  });
+  return rows.map(rowToQuest);
+}
+async function updateQuestStatus(db, questId, userId, status) {
+  const now = Date.now();
+  await db.update(quests).set({
+    status,
+    completedAt: status === "completed" ? now : null,
+    streakCount: status === "abandoned" ? 0 : void 0
+  }).where(and(eq(quests.id, questId), eq(quests.userId, userId)));
+}
+async function completeQuest(db, input) {
+  const { userId, ...rest } = input;
+  const validInput = completeQuestInputSchema.parse(rest);
+  const completedAt = validInput.completedAt ?? Date.now();
+  const quest = await db.query.quests.findFirst({
+    where: and(eq(quests.id, validInput.questId), eq(quests.userId, userId))
+  });
+  if (!quest) throw new Error("Quest not found");
+  if (quest.status === "completed") throw new Error("Quest already completed");
+  if (quest.status === "abandoned") throw new Error("Cannot complete an abandoned quest");
+  const xpResult = calculateQuestXp({
+    baseXp: quest.baseXp,
+    difficulty: questDifficultySchema.parse(quest.difficulty),
+    streakDays: quest.streakCount,
+    proofType: validInput.proofType
+  });
+  const skillTags = quest.skillTags;
+  let skillGains = [];
+  const proofConfidence = validInput.proofConfidence ?? (typeof validInput.proofData.confidence === "number" && validInput.proofData.confidence >= 0 && validInput.proofData.confidence <= 1 ? validInput.proofData.confidence : void 0);
+  await db.transaction(async (tx) => {
+    await tx.update(quests).set({
+      status: "completed",
+      completedAt,
+      streakCount: quest.streakCount + 1
+    }).where(eq(quests.id, validInput.questId));
+    const [questLog] = await tx.insert(questLogs).values({
+      questId: quest.id,
+      userId: quest.userId,
+      completedAt,
+      durationMinutes: validInput.durationMinutes,
+      xpEarned: xpResult.totalXp,
+      proofType: validInput.proofType,
+      proofData: validInput.proofData,
+      streakDay: quest.streakCount + 1
+    }).returning();
+    if (!questLog) {
+      throw new Error("Failed to insert quest log");
+    }
+    await tx.insert(proofs).values({
+      questLogId: questLog.id,
+      type: validInput.proofType,
+      ...proofConfidence !== void 0 ? { confidence: proofConfidence } : {},
+      data: validInput.proofData
+    });
+    const user = await tx.query.users.findFirst({ where: eq(users.id, quest.userId) });
+    if (user) {
+      const newXp = user.totalXp + xpResult.totalXp;
+      await tx.update(users).set({ totalXp: newXp, level: levelFromXp(newXp) }).where(eq(users.id, quest.userId));
+    }
+    skillGains = await distributeSkillXp(tx, quest.userId, skillTags, xpResult.totalXp);
+  });
+  return { xpEarned: xpResult.totalXp, skillGains };
+}
+async function updateQuest(db, questId, userId, patch) {
+  const set = { updatedAt: Date.now() };
+  if (patch.title !== void 0) set.title = patch.title;
+  if (patch.description !== void 0) set.description = patch.description;
+  if (patch.type !== void 0) set.type = patch.type;
+  if (patch.difficulty !== void 0) set.difficulty = patch.difficulty;
+  if (patch.skillTags !== void 0) set.skillTags = patch.skillTags;
+  if (patch.baseXp !== void 0) set.baseXp = patch.baseXp;
+  if (patch.scheduleCron !== void 0) set.scheduleCron = patch.scheduleCron;
+  if (patch.deadlineAt !== void 0) set.deadlineAt = patch.deadlineAt;
+  const [row] = await db.update(quests).set(set).where(and(eq(quests.id, questId), eq(quests.userId, userId))).returning();
+  return row ? rowToQuest(row) : null;
+}
+async function listQuestLogs(db, userId, options = {}) {
+  const { limit = 20, since } = options;
+  const where = since ? and(eq(questLogs.userId, userId), gte(questLogs.completedAt, since)) : eq(questLogs.userId, userId);
+  return db.query.questLogs.findMany({
+    where,
+    orderBy: [desc(questLogs.completedAt)],
+    limit
+  });
+}
+async function createConversation(db, userId, title) {
+  const [row] = await db.insert(conversations).values({ userId, title: null }).returning();
+  if (!row) throw new Error("Failed to create conversation");
+  return row;
+}
+async function getConversationById(db, id) {
+  const row = await db.query.conversations.findFirst({
+    where: eq(conversations.id, id)
+  });
+  return row ?? null;
+}
+async function listConversations(db, userId, limit = 20) {
+  return db.query.conversations.findMany({
+    where: eq(conversations.userId, userId),
+    orderBy: [desc(conversations.updatedAt)],
+    limit
+  });
+}
+async function appendMessage(db, conversationId, msg) {
+  const [row] = await db.insert(messages).values({
+    conversationId,
+    role: msg.role,
+    content: msg.content,
+    toolCalls: msg.toolCalls,
+    toolResults: msg.toolResults,
+    ...msg.attachments ? { attachments: msg.attachments } : {}
+  }).returning();
+  if (!row) throw new Error("Failed to insert message");
+  await db.update(conversations).set({ updatedAt: Date.now() }).where(eq(conversations.id, conversationId));
+  return row;
+}
+async function getConversationMessages(db, conversationId, limit = 50) {
+  return db.query.messages.findMany({
+    where: eq(messages.conversationId, conversationId),
+    orderBy: [desc(messages.createdAt)],
+    limit
+  });
+}
+function storedToModelMessages(stored) {
+  const sorted = [...stored].sort((a, b) => a.createdAt - b.createdAt);
+  const result = [];
+  for (const msg of sorted) {
+    if (msg.role === "user") {
+      if (msg.attachments?.length) {
+        result.push({
+          role: "user",
+          content: [
+            ...msg.attachments.map((a) => ({
+              type: "image",
+              image: a.base64,
+              mediaType: a.mime
+            })),
+            { type: "text", text: msg.content }
+          ]
+        });
+      } else {
+        result.push({ role: "user", content: msg.content });
+      }
+    } else if (msg.role === "assistant") {
+      result.push({ role: "assistant", content: msg.content });
+    }
+  }
+  return result;
+}
+const PROMPT_HISTORY_MAX = 100;
+async function appendPromptHistory(db, userId, content) {
+  await db.insert(promptHistory).values({ userId, content });
+  const rows = await db.query.promptHistory.findMany({
+    where: eq(promptHistory.userId, userId),
+    orderBy: [desc(promptHistory.createdAt)],
+    columns: { id: true }
+  });
+  if (rows.length > PROMPT_HISTORY_MAX) {
+    const excess = rows.slice(PROMPT_HISTORY_MAX).map((r) => r.id);
+    await db.delete(promptHistory).where(inArray(promptHistory.id, excess));
+  }
+}
+async function getPromptHistory(db, userId) {
+  const rows = await db.query.promptHistory.findMany({
+    where: eq(promptHistory.userId, userId),
+    orderBy: [asc(promptHistory.createdAt)],
+    limit: PROMPT_HISTORY_MAX,
+    columns: { content: true }
+  });
+  return rows.map((r) => r.content);
+}
+export {
+  listSkillsByUser as a,
+  listConversations as b,
+  createServerRpc as c,
+  getPromptHistory as d,
+  appendPromptHistory as e,
+  createQuest as f,
+  getCompanionByUserId as g,
+  completeQuest as h,
+  getQuestById as i,
+  updateCompanionMode as j,
+  listCompanionInsights as k,
+  listQuestsByUser as l,
+  deleteCompanionInsight as m,
+  findQuestByPrefix as n,
+  updateQuest as o,
+  listQuestLogs as p,
+  updateCompanionUserContext as q,
+  updateCompanionInsight as r,
+  findCompanionInsightByContent as s,
+  createCompanionInsight as t,
+  updateQuestStatus as u,
+  getConversationById as v,
+  createConversation as w,
+  appendMessage as x,
+  getConversationMessages as y,
+  storedToModelMessages as z
+};

package/dist/web/server/assets/start-HYkvq4Ni.js

@@ -0,0 +1,4 @@
+const startInstance = void 0;
+export {
+  startInstance
+};

package/dist/web/server/assets/token-DGoahKjI.js

@@ -0,0 +1,86 @@
+import { a7 as getDefaultExportFromCjs } from "./vault.server-CscY5Z8e.js";
+import { a2 as requireTokenError } from "./agent.functions-BL3upUNr.js";
+import { r as requireTokenUtil } from "./token-util-BopJPy-I.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var token$2;
+var hasRequiredToken;
+function requireToken() {
+  if (hasRequiredToken) return token$2;
+  hasRequiredToken = 1;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var token_exports = {};
+  __export(token_exports, {
+    refreshToken: () => refreshToken
+  });
+  token$2 = __toCommonJS(token_exports);
+  var import_token_error = requireTokenError();
+  var import_token_util = requireTokenUtil();
+  async function refreshToken() {
+    const { projectId, teamId } = (0, import_token_util.findProjectInfo)();
+    let maybeToken = (0, import_token_util.loadToken)(projectId);
+    if (!maybeToken || (0, import_token_util.isExpired)((0, import_token_util.getTokenPayload)(maybeToken.token))) {
+      const authToken = await (0, import_token_util.getVercelCliToken)();
+      if (!authToken) {
+        throw new import_token_error.VercelOidcTokenError(
+          "Failed to refresh OIDC token: Log in to Vercel CLI and link your project with `vc link`"
+        );
+      }
+      if (!projectId) {
+        throw new import_token_error.VercelOidcTokenError(
+          "Failed to refresh OIDC token: Try re-linking your project with `vc link`"
+        );
+      }
+      maybeToken = await (0, import_token_util.getVercelOidcToken)(authToken, projectId, teamId);
+      if (!maybeToken) {
+        throw new import_token_error.VercelOidcTokenError("Failed to refresh OIDC token");
+      }
+      (0, import_token_util.saveToken)(maybeToken, projectId);
+    }
+    process.env.VERCEL_OIDC_TOKEN = maybeToken.token;
+    return;
+  }
+  return token$2;
+}
+var tokenExports = requireToken();
+const token = /* @__PURE__ */ getDefaultExportFromCjs(tokenExports);
+const token$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: token
+}, [tokenExports]);
+export {
+  token$1 as t
+};