vibefast-cli 0.2.4 → 0.3.1

package/2/packages/backend/convex/_generated/api.js

@@ -0,0 +1,23 @@
+/* eslint-disable */
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import { anyApi, componentsGeneric } from "convex/server";
+
+/**
+ * A utility for referencing Convex functions in your app's API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export const api = anyApi;
+export const internal = anyApi;
+export const components = componentsGeneric();

package/2/packages/backend/convex/_generated/dataModel.d.ts

@@ -0,0 +1,60 @@
+/* eslint-disable */
+/**
+ * Generated data model types.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type {
+  DataModelFromSchemaDefinition,
+  DocumentByName,
+  TableNamesInDataModel,
+  SystemTableNames,
+} from "convex/server";
+import type { GenericId } from "convex/values";
+import schema from "../schema.js";
+
+/**
+ * The names of all of your Convex tables.
+ */
+export type TableNames = TableNamesInDataModel<DataModel>;
+
+/**
+ * The type of a document stored in Convex.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Doc<TableName extends TableNames> = DocumentByName<
+  DataModel,
+  TableName
+>;
+
+/**
+ * An identifier for a document in Convex.
+ *
+ * Convex documents are uniquely identified by their `Id`, which is accessible
+ * on the `_id` field. To learn more, see [Document IDs](https://docs.convex.dev/using/document-ids).
+ *
+ * Documents can be loaded using `db.get(id)` in query and mutation functions.
+ *
+ * IDs are just strings at runtime, but this type can be used to distinguish them from other
+ * strings when type checking.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Id<TableName extends TableNames | SystemTableNames> =
+  GenericId<TableName>;
+
+/**
+ * A type describing your Convex data model.
+ *
+ * This type includes information about what tables you have, the type of
+ * documents stored in those tables, and the indexes defined on them.
+ *
+ * This type is used to parameterize methods like `queryGeneric` and
+ * `mutationGeneric` to make them type-safe.
+ */
+export type DataModel = DataModelFromSchemaDefinition<typeof schema>;

package/2/packages/backend/convex/_generated/server.d.ts

@@ -0,0 +1,149 @@
+/* eslint-disable */
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import {
+  ActionBuilder,
+  AnyComponents,
+  HttpActionBuilder,
+  MutationBuilder,
+  QueryBuilder,
+  GenericActionCtx,
+  GenericMutationCtx,
+  GenericQueryCtx,
+  GenericDatabaseReader,
+  GenericDatabaseWriter,
+  FunctionReference,
+} from "convex/server";
+import type { DataModel } from "./dataModel.js";
+
+type GenericCtx =
+  | GenericActionCtx<DataModel>
+  | GenericMutationCtx<DataModel>
+  | GenericQueryCtx<DataModel>;
+
+/**
+ * Define a query in this Convex app's public API.
+ *
+ * This function will be allowed to read your Convex database and will be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export declare const query: QueryBuilder<DataModel, "public">;
+
+/**
+ * Define a query that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to read from your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export declare const internalQuery: QueryBuilder<DataModel, "internal">;
+
+/**
+ * Define a mutation in this Convex app's public API.
+ *
+ * This function will be allowed to modify your Convex database and will be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export declare const mutation: MutationBuilder<DataModel, "public">;
+
+/**
+ * Define a mutation that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to modify your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export declare const internalMutation: MutationBuilder<DataModel, "internal">;
+
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
+ */
+export declare const action: ActionBuilder<DataModel, "public">;
+
+/**
+ * Define an action that is only accessible from other Convex functions (but not from the client).
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
+ */
+export declare const internalAction: ActionBuilder<DataModel, "internal">;
+
+/**
+ * Define an HTTP action.
+ *
+ * This function will be used to respond to HTTP requests received by a Convex
+ * deployment if the requests matches the path and method where this action
+ * is routed. Be sure to route your action in `convex/http.js`.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
+ */
+export declare const httpAction: HttpActionBuilder;
+
+/**
+ * A set of services for use within Convex query functions.
+ *
+ * The query context is passed as the first argument to any Convex query
+ * function run on the server.
+ *
+ * This differs from the {@link MutationCtx} because all of the services are
+ * read-only.
+ */
+export type QueryCtx = GenericQueryCtx<DataModel>;
+
+/**
+ * A set of services for use within Convex mutation functions.
+ *
+ * The mutation context is passed as the first argument to any Convex mutation
+ * function run on the server.
+ */
+export type MutationCtx = GenericMutationCtx<DataModel>;
+
+/**
+ * A set of services for use within Convex action functions.
+ *
+ * The action context is passed as the first argument to any Convex action
+ * function run on the server.
+ */
+export type ActionCtx = GenericActionCtx<DataModel>;
+
+/**
+ * An interface to read from the database within Convex query functions.
+ *
+ * The two entry points are {@link DatabaseReader.get}, which fetches a single
+ * document by its {@link Id}, or {@link DatabaseReader.query}, which starts
+ * building a query.
+ */
+export type DatabaseReader = GenericDatabaseReader<DataModel>;
+
+/**
+ * An interface to read from and write to the database within Convex mutation
+ * functions.
+ *
+ * Convex guarantees that all writes within a single mutation are
+ * executed atomically, so you never have to worry about partial writes leaving
+ * your data in an inconsistent state. See [the Convex Guide](https://docs.convex.dev/understanding/convex-fundamentals/functions#atomicity-and-optimistic-concurrency-control)
+ * for the guarantees Convex provides your functions.
+ */
+export type DatabaseWriter = GenericDatabaseWriter<DataModel>;

package/2/packages/backend/convex/_generated/server.js

@@ -0,0 +1,90 @@
+/* eslint-disable */
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import {
+  actionGeneric,
+  httpActionGeneric,
+  queryGeneric,
+  mutationGeneric,
+  internalActionGeneric,
+  internalMutationGeneric,
+  internalQueryGeneric,
+  componentsGeneric,
+} from "convex/server";
+
+/**
+ * Define a query in this Convex app's public API.
+ *
+ * This function will be allowed to read your Convex database and will be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const query = queryGeneric;
+
+/**
+ * Define a query that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to read from your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const internalQuery = internalQueryGeneric;
+
+/**
+ * Define a mutation in this Convex app's public API.
+ *
+ * This function will be allowed to modify your Convex database and will be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const mutation = mutationGeneric;
+
+/**
+ * Define a mutation that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to modify your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const internalMutation = internalMutationGeneric;
+
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
+ */
+export const action = actionGeneric;
+
+/**
+ * Define an action that is only accessible from other Convex functions (but not from the client).
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
+ */
+export const internalAction = internalActionGeneric;
+
+/**
+ * Define a Convex HTTP action.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument, and a `Request` object
+ * as its second.
+ * @returns The wrapped endpoint function. Route a URL path to this function in `convex/http.js`.
+ */
+export const httpAction = httpActionGeneric;

package/2/packages/backend/convex/agents.ts

@@ -0,0 +1,116 @@
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { openai } from '@ai-sdk/openai';
+import type { LanguageModelV1 } from '@ai-sdk/provider';
+import { Agent } from '@convex-dev/agent';
+
+import { components } from './_generated/api';
+import {
+  knowledgeRetrievalTool,
+  tavilySearchTool,
+  userProfileTool,
+} from './tools';
+
+const google = createGoogleGenerativeAI();
+
+type ModelProvider = 'openai' | 'google';
+
+type ModelResolver = () => {
+  model: LanguageModelV1;
+  provider: ModelProvider;
+  modelId: string;
+};
+
+const PROVIDER_CHAT_FACTORIES: Record<
+  ModelProvider,
+  (modelId: string) => LanguageModelV1
+> = {
+  openai: (modelId) => openai.chat(modelId),
+  google: (modelId) => google.chat(modelId),
+};
+
+const MODEL_CONFIGS = {
+  'gpt-4.1-nano': { provider: 'openai', modelId: 'gpt-4.1-nano' },
+  'gpt-5': { provider: 'openai', modelId: 'gpt-5' },
+  'gpt-5-nano': { provider: 'openai', modelId: 'gpt-5-nano' },
+  'gpt-4o-mini': { provider: 'openai', modelId: 'gpt-4o-mini' },
+  'gpt-4o': { provider: 'openai', modelId: 'gpt-4o' },
+  'gemini-2.0-flash': {
+    provider: 'google',
+    modelId: 'models/gemini-2.0-flash',
+  },
+  'gemini-1.5-flash': {
+    provider: 'google',
+    modelId: 'models/gemini-1.5-flash',
+  },
+  'gemini-1.5-pro': { provider: 'google', modelId: 'models/gemini-1.5-pro' },
+  'gemini-2.5-flash': {
+    provider: 'google',
+    modelId: 'models/gemini-2.5-flash-preview-05-20',
+  },
+  'gemini-2.5-pro': {
+    provider: 'google',
+    modelId: 'models/gemini-2.5-pro-preview-06-05',
+  },
+} satisfies Record<string, { provider: ModelProvider; modelId: string }>;
+
+const MODEL_RESOLVERS = Object.fromEntries(
+  Object.entries(MODEL_CONFIGS).map(([key, config]) => [
+    key,
+    () => ({
+      model: PROVIDER_CHAT_FACTORIES[config.provider](config.modelId),
+      provider: config.provider,
+      modelId: config.modelId,
+    }),
+  ]),
+) as Record<string, ModelResolver>;
+
+const DEFAULT_MODEL: keyof typeof MODEL_CONFIGS = 'gpt-4.1-nano';
+
+export function resolveChatModel(preferredModel?: string) {
+  const modelKey =
+    preferredModel && MODEL_RESOLVERS[preferredModel]
+      ? preferredModel
+      : DEFAULT_MODEL;
+
+  const resolver = MODEL_RESOLVERS[modelKey] ?? MODEL_RESOLVERS[DEFAULT_MODEL];
+
+  try {
+    return resolver();
+  } catch (error) {
+    if (modelKey !== DEFAULT_MODEL) {
+      return MODEL_RESOLVERS[DEFAULT_MODEL]();
+    }
+    throw error;
+  }
+}
+
+export const agent: Agent = new Agent(components.agent, {
+  name: 'VibeFast Assistant',
+  chat: MODEL_RESOLVERS[DEFAULT_MODEL]().model,
+  instructions: `
+You are VibeFast, a proactive mobile AI assistant. Produce concise, friendly responses with clear structure.
+
+- Use markdown for readability (lists, bold keywords, inline code where appropriate).
+- When a question depends on current or niche information, call the tavilySearch tool first and cite the findings.
+- When the user asks about their account, credits, or profile details, call the userProfile tool before answering.
+- When the user references uploaded files or knowledge base material, call the knowledgeRetrieval tool with relevant filters to ground your answer.
+- For image attachments, describe what you see before reasoning about it.
+- If a user asks for something you cannot do, gracefully explain the limitation and offer an alternative.
+- Keep responses focused on the user's goal; avoid unnecessary chatter.
+`.trim(),
+  tools: {
+    knowledgeRetrieval: knowledgeRetrievalTool,
+    tavilySearch: tavilySearchTool,
+    userProfile: userProfileTool,
+  },
+  maxSteps: 6,
+  contextOptions: {
+    recentMessages: 50,
+  },
+  storageOptions: {
+    saveMessages: 'promptAndOutput',
+  },
+});
+
+export const SUPPORTED_MODEL_KEYS = Object.keys(MODEL_RESOLVERS);
+export { DEFAULT_MODEL };

package/2/packages/backend/convex/auth.config.ts

@@ -0,0 +1,8 @@
+export default {
+  providers: [
+    {
+      domain: process.env.CONVEX_SITE_URL,
+      applicationID: 'convex',
+    },
+  ],
+};

package/2/packages/backend/convex/auth.ts

@@ -0,0 +1,103 @@
+import Apple from '@auth/core/providers/apple';
+import GitHub from '@auth/core/providers/github';
+import Google from '@auth/core/providers/google';
+import { Anonymous } from '@convex-dev/auth/providers/Anonymous';
+import { Password } from '@convex-dev/auth/providers/Password';
+import { convexAuth } from '@convex-dev/auth/server';
+
+import { getAllowedRedirects } from './lib/config';
+
+export const { auth, signIn, signOut, store, isAuthenticated } = convexAuth({
+  providers: [
+    Password,
+    Anonymous,
+    Google,
+    Apple({
+      // IMPORTANT: force query mode so we can read ?code=... in the app
+      authorization: {
+        params: {
+          response_mode: 'query',
+          response_type: 'code', // be explicit
+          // Avoid requesting name/email here; see note below
+          scope: '', // (omit or set to empty so Apple doesn't force form_post)
+        },
+      },
+      profile: (appleInfo) => {
+        const name = appleInfo.user
+          ? `${appleInfo.user.name.firstName} ${appleInfo.user.name.lastName}`
+          : undefined;
+        return { id: appleInfo.sub, name, email: appleInfo.email };
+      },
+    }),
+    GitHub,
+  ],
+  jwt: {
+    durationMs: 24 * 60 * 60 * 1000, // 24 hours (extended for debugging)
+  },
+  session: {
+    totalDurationMs: 30 * 24 * 60 * 60 * 1000, // 30 days
+    inactiveDurationMs: 30 * 24 * 60 * 60 * 1000, // 30 days
+  },
+  callbacks: {
+    async redirect({ redirectTo }) {
+      console.log('👉 redirectTo received:', JSON.stringify(redirectTo));
+
+      const normalized = redirectTo?.trim();
+
+      const allowed = getAllowedRedirects();
+
+      if (!allowed.includes(normalized)) {
+        throw new Error(`Invalid redirectTo: ${normalized}`);
+      }
+
+      return normalized;
+    },
+    async afterUserCreatedOrUpdated(ctx, { userId, existingUserId }) {
+      console.log(
+        `[Auth] afterUserCreatedOrUpdated: userId=${userId}, existingUserId=${existingUserId}`,
+      );
+
+      // Get the user document to check current state
+      const user = await ctx.db.get(userId);
+      if (!user) {
+        console.error(`[Auth] User not found: ${userId}`);
+        return;
+      }
+
+      const updates: Record<string, unknown> = {};
+
+      // For new users (existingUserId is null), ensure credits field is initialized
+      if (!existingUserId) {
+        console.log('[Auth] New user created, initializing credits field');
+
+        if (typeof user.credits !== 'number') {
+          console.log(
+            '[Auth] User has no credits field, setting to 0 (will be granted by device grant system)',
+          );
+          updates.credits = 0;
+        }
+
+        // For OAuth providers, automatically mark email as verified
+        // OAuth providers (Google, Apple, GitHub) verify emails as part of their flow
+        if (user.email && !user.emailVerified) {
+          console.log(
+            `[Auth] New OAuth user detected, marking email as verified: ${user.email}`,
+          );
+          updates.emailVerified = Date.now();
+          updates.emailVerificationTime = Date.now(); // Update both fields for compatibility
+        }
+      }
+
+      // Apply updates if any
+      if (Object.keys(updates).length > 0) {
+        await ctx.db.patch(userId, updates);
+        console.log(`[Auth] Updated user ${userId} with:`, updates);
+      }
+    },
+  },
+});
+
+// Helper types for contexts if needed elsewhere
+// export type FullQueryCtx = QueryCtx<DataModel>;
+// export type FullMutationCtx = MutationCtx<DataModel>;
+// export type FullActionCtx = ActionCtx<DataModel>;