@vibeiao/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,465 @@
+import {
+  SelfReliance,
+  createAutoSelfReliance,
+  createSelfRelianceMonitor,
+  createSelfReliancePolicy,
+  createSurvivalMiddleware,
+  withSurvival
+} from "./chunk-BFAMXH2X.js";
+import {
+  VIBEIAO_IDL,
+  fetchSolBalance,
+  fetchTokenBalance,
+  fetchTokenBalances
+} from "./chunk-OUGOOS3F.js";
+
+// src/index.ts
+var pickFinite = (...values) => {
+  for (const value of values) {
+    const num = typeof value === "number" ? value : Number(value);
+    if (Number.isFinite(num)) return num;
+  }
+  return NaN;
+};
+var buildClaimMessage = (nonce) => `VIBEIAO-CLAIM:${nonce}`;
+var buildOwnerTransferMessage = (listingId, newOwnerWallet, nonce) => `VIBEIAO-OWNER-TRANSFER:${listingId}:${newOwnerWallet}:${nonce}`;
+var buildMemoryPingMessage = (listingId, timestamp) => `VIBEIAO-MEMORY-PING:${listingId}:${timestamp}`;
+var buildListingVersionMessage = (listingId, version, timestamp) => `VIBEIAO-LISTING-VERSION:${listingId}:${version}:${timestamp}`;
+var buildReviewResponseMessage = (reviewId, status, timestamp) => `VIBEIAO-REVIEW-RESPONSE:${reviewId}:${status}:${timestamp}`;
+var buildReviewPrompt = () => "After using this tool once, provide a 1-5 star rating and a short comment (what worked, what failed, what to improve).";
+var buildReviewRequired = (listingId, redeemSignature, appVersion, options = {}) => {
+  const base = withTrailingSlash(options.baseUrl || DEFAULT_API_BASE);
+  return {
+    listingId,
+    redeemSignature,
+    appVersion,
+    reviewUrl: `${base}/v1/listings/${listingId}/reviews`
+  };
+};
+var ReviewGate = class {
+  pending = /* @__PURE__ */ new Map();
+  key(listingId, wallet) {
+    return `${listingId}:${wallet}`;
+  }
+  require(record) {
+    this.pending.set(this.key(record.listingId, record.wallet), record);
+    return record;
+  }
+  get(listingId, wallet) {
+    return this.pending.get(this.key(listingId, wallet));
+  }
+  clear(listingId, wallet) {
+    this.pending.delete(this.key(listingId, wallet));
+  }
+  assertClear(listingId, wallet) {
+    if (this.pending.has(this.key(listingId, wallet))) {
+      throw new Error("review_pending");
+    }
+  }
+};
+var DEFAULT_API_BASE = "https://api.vibeiao.com";
+var DEFAULT_WEB_BASE = "https://vibeiao.com";
+var withTrailingSlash = (value) => value.endsWith("/") ? value.slice(0, -1) : value;
+var readJson = async (response) => {
+  const text = await response.text();
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    const snippet = text.trim().slice(0, 160);
+    const err = new Error("invalid_json_response");
+    err.details = { status: response.status, snippet };
+    throw err;
+  }
+};
+var unwrap = (response) => {
+  if (response.error) {
+    throw new Error(response.error);
+  }
+  return response.data;
+};
+var generateRef = () => {
+  const cryptoObj = globalThis.crypto;
+  if (cryptoObj?.randomUUID) {
+    return cryptoObj.randomUUID();
+  }
+  return Math.random().toString(36).slice(2, 10);
+};
+var buildQuery = (params) => {
+  const query = new URLSearchParams();
+  Object.entries(params).forEach(([key, value]) => {
+    if (value === void 0 || value === null || value === "") return;
+    query.set(key, String(value));
+  });
+  const queryString = query.toString();
+  return queryString ? `?${queryString}` : "";
+};
+var VibeClient = class {
+  baseUrl;
+  fetcher;
+  constructor(options = {}) {
+    this.baseUrl = withTrailingSlash(options.baseUrl || DEFAULT_API_BASE);
+    this.fetcher = options.fetcher || fetch;
+  }
+  async createClaim(wallet, purpose) {
+    return this.post("/v1/claims", { wallet, purpose });
+  }
+  async verifyClaim(claimId, signature) {
+    return this.post(`/v1/claims/${claimId}/verify`, { signature });
+  }
+  async createListing(claimId, listing, ownerClaimId) {
+    return this.post("/v1/listings", { claimId, ownerClaimId, listing });
+  }
+  async registerAgent(claimId, listing, ownerClaimId) {
+    return this.post("/v1/agents/register", { claimId, ownerClaimId, listing });
+  }
+  async updateListingStatus(listingId, claimId, status) {
+    return this.post(`/v1/listings/${listingId}/status`, { claimId, status });
+  }
+  async updateListingPrice(listingId, claimId, priceUsdc) {
+    return this.post(`/v1/listings/${listingId}/price`, { claimId, priceUsdc });
+  }
+  async transferOwner(listingId, claimId, signature) {
+    return this.post(
+      `/v1/listings/${listingId}/owner-transfer`,
+      { claimId, signature }
+    );
+  }
+  async reportMemory(listingId, payload) {
+    return this.post(
+      `/v1/agents/${listingId}/memory`,
+      payload
+    );
+  }
+  async listListings(filters = {}) {
+    const query = buildQuery({
+      type: filters.type,
+      status: filters.status,
+      category: filters.category,
+      q: filters.q,
+      llmRequired: filters.llmRequired,
+      sort: filters.sort,
+      limit: filters.limit,
+      offset: filters.offset
+    });
+    return this.get(`/v1/listings${query}`);
+  }
+  async getListing(id) {
+    return this.get(`/v1/listings/${id}`);
+  }
+  async getListingReviews(listingId, options) {
+    const query = buildQuery({ limit: options?.limit, offset: options?.offset });
+    return this.get(`/v1/listings/${listingId}/reviews${query}`);
+  }
+  async createListingReview(listingId, payload) {
+    return this.post(`/v1/listings/${listingId}/reviews`, payload);
+  }
+  async respondToListingReview(listingId, reviewId, payload) {
+    return this.post(
+      `/v1/listings/${listingId}/reviews/${reviewId}/response`,
+      payload
+    );
+  }
+  async updateListingVersion(listingId, payload) {
+    return this.post(
+      `/v1/listings/${listingId}/version`,
+      payload
+    );
+  }
+  async getLeaderboard(filters = {}) {
+    const query = buildQuery({
+      type: filters.type,
+      window: filters.window,
+      limit: filters.limit
+    });
+    return this.get(`/v1/leaderboard${query}`);
+  }
+  async getListingAnalytics(listingId, window = "7d") {
+    const query = buildQuery({ window });
+    return this.get(`/v1/listings/${listingId}/analytics${query}`);
+  }
+  async getListingBuybacks(listingId, limit = 20) {
+    const query = buildQuery({ limit });
+    return this.get(`/v1/listings/${listingId}/buybacks${query}`);
+  }
+  async getOpenRouterCredits(apiKey) {
+    return this.post("/v1/openrouter/credits", { apiKey });
+  }
+  async getOpenRouterCreditsValue(apiKey) {
+    const result = await this.getOpenRouterCredits(apiKey);
+    if (result.error) return { error: result.error, details: result.details };
+    const data = result.data;
+    let credits = pickFinite(
+      data?.credits,
+      data?.remaining_credits,
+      data?.remainingCredits,
+      data?.total_credits,
+      data?.totalCredits
+    );
+    if (!Number.isFinite(credits)) {
+      const nested = data?.data;
+      credits = pickFinite(
+        nested?.credits,
+        nested?.remaining_credits,
+        nested?.remainingCredits,
+        nested?.total_credits,
+        nested?.totalCredits
+      );
+    }
+    if (!Number.isFinite(credits)) {
+      const total = pickFinite(
+        data?.total_credits,
+        data?.totalCredits,
+        data?.data?.total_credits,
+        data?.data?.totalCredits
+      );
+      const spent = pickFinite(
+        data?.total_spent,
+        data?.totalSpent,
+        data?.data?.total_spent,
+        data?.data?.totalSpent
+      );
+      if (Number.isFinite(total) && Number.isFinite(spent)) {
+        credits = Math.max(0, total - spent);
+      }
+    }
+    if (!Number.isFinite(credits)) {
+      return { error: "credits_unavailable" };
+    }
+    return { data: credits };
+  }
+  async getSolUsdPrice() {
+    return this.get("/v1/prices/sol");
+  }
+  async verifyTicket(token, options) {
+    const params = new URLSearchParams({ token });
+    if (options?.listingAccount) params.set("listing", options.listingAccount);
+    if (options?.wallet) params.set("wallet", options.wallet);
+    const response = await this.fetcher(`${this.baseUrl}/v1/verify?${params.toString()}`);
+    try {
+      const payload = await readJson(response);
+      return payload;
+    } catch (error) {
+      return {
+        isValid: false,
+        error: error instanceof Error ? error.message : "invalid_json_response"
+      };
+    }
+  }
+  async verifyRedeem(signature, options) {
+    const params = new URLSearchParams({ token: signature, mode: "redeem" });
+    if (options?.listingAccount) params.set("listing", options.listingAccount);
+    if (options?.wallet) params.set("wallet", options.wallet);
+    const maxAge = options?.maxAgeSec ?? options?.maxAge;
+    if (maxAge) params.set("maxAgeSec", String(maxAge));
+    if (options?.requireReview) params.set("requireReview", "true");
+    const response = await this.fetcher(`${this.baseUrl}/v1/verify?${params.toString()}`);
+    try {
+      const payload = await readJson(response);
+      return payload;
+    } catch (error) {
+      return {
+        isValid: false,
+        error: error instanceof Error ? error.message : "invalid_json_response"
+      };
+    }
+  }
+  async verifyReceipt(listingAccount, wallet, options) {
+    const params = new URLSearchParams({ listing: listingAccount, wallet, mode: "receipt" });
+    if (options?.minCount) params.set("minCount", String(options.minCount));
+    const maxAge = options?.maxAgeSec ?? options?.maxAge;
+    if (maxAge) params.set("maxAgeSec", String(maxAge));
+    const response = await this.fetcher(`${this.baseUrl}/v1/verify?${params.toString()}`);
+    try {
+      const payload = await readJson(response);
+      return payload;
+    } catch (error) {
+      return {
+        isValid: false,
+        error: error instanceof Error ? error.message : "invalid_json_response"
+      };
+    }
+  }
+  async get(path) {
+    const response = await this.fetcher(`${this.baseUrl}${path}`);
+    let payload = null;
+    try {
+      payload = await readJson(response);
+    } catch (error) {
+      const details = error instanceof Error && "details" in error ? error.details : void 0;
+      return { error: "invalid_json_response", details };
+    }
+    if (!response.ok) {
+      return { error: payload?.error || "request_failed", details: payload?.details };
+    }
+    if (!payload) {
+      return { error: "empty_response" };
+    }
+    return payload;
+  }
+  async post(path, body) {
+    const response = await this.fetcher(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    let payload = null;
+    try {
+      payload = await readJson(response);
+    } catch (error) {
+      const details = error instanceof Error && "details" in error ? error.details : void 0;
+      return { error: "invalid_json_response", details };
+    }
+    if (!response.ok) {
+      return { error: payload?.error || "request_failed", details: payload?.details };
+    }
+    if (!payload) {
+      return { error: "empty_response" };
+    }
+    return payload;
+  }
+};
+var VibeRegistry = class {
+  client;
+  constructor(options = {}) {
+    this.client = new VibeClient(options);
+  }
+  async listListings(filters = {}) {
+    return unwrap(await this.client.listListings(filters));
+  }
+  async listAgents(filters = {}) {
+    return unwrap(await this.client.listListings({ ...filters, type: "agent" }));
+  }
+  async listHumans(filters = {}) {
+    return unwrap(await this.client.listListings({ ...filters, type: "human" }));
+  }
+  async getListing(id) {
+    return unwrap(await this.client.getListing(id));
+  }
+  async getListingReviews(listingId, options) {
+    return unwrap(await this.client.getListingReviews(listingId, options));
+  }
+  async createListingReview(listingId, payload) {
+    return unwrap(await this.client.createListingReview(listingId, payload));
+  }
+  async respondToListingReview(listingId, reviewId, payload) {
+    return unwrap(await this.client.respondToListingReview(listingId, reviewId, payload));
+  }
+  async updateListingVersion(listingId, payload) {
+    return unwrap(await this.client.updateListingVersion(listingId, payload));
+  }
+  async getLeaderboard(filters = {}) {
+    return unwrap(await this.client.getLeaderboard(filters));
+  }
+  async getListingAnalytics(listingId, window = "7d") {
+    return unwrap(await this.client.getListingAnalytics(listingId, window));
+  }
+  async getListingBuybacks(listingId, limit = 20) {
+    return unwrap(await this.client.getListingBuybacks(listingId, limit));
+  }
+  async getOpenRouterCredits(apiKey) {
+    return unwrap(await this.client.getOpenRouterCredits(apiKey));
+  }
+  async getOpenRouterCreditsValue(apiKey) {
+    const result = await this.client.getOpenRouterCreditsValue(apiKey);
+    return unwrap(result);
+  }
+  async getSolUsdPrice() {
+    return unwrap(await this.client.getSolUsdPrice());
+  }
+  async verifyReceipt(listingAccount, wallet, options) {
+    const result = await this.client.verifyReceipt(listingAccount, wallet, options);
+    if (result.error) {
+      throw new Error(result.error);
+    }
+    return result;
+  }
+  async verifyRedeem(signature, options) {
+    const result = await this.client.verifyRedeem(signature, options);
+    if (result.error) {
+      throw new Error(result.error);
+    }
+    return result;
+  }
+};
+var buildShareLink = (listingId, options = {}) => {
+  const base = withTrailingSlash(options.webBaseUrl || DEFAULT_WEB_BASE);
+  const ref = options.ref || generateRef();
+  const params = new URLSearchParams({ listing: listingId, ref });
+  if (options.source) params.set("utm_source", options.source);
+  if (options.medium) params.set("utm_medium", options.medium);
+  if (options.campaign) params.set("utm_campaign", options.campaign);
+  if (options.content) params.set("utm_content", options.content);
+  return `${base}/?${params.toString()}`;
+};
+var buildShareCopy = (listing, options = {}) => {
+  const link = buildShareLink(listing.id, options);
+  return `${listing.name} \u2014 ${listing.tagline}. Try it on VIBEIAO: ${link}`;
+};
+var buildBadgeMarkdown = (listing, options = {}) => {
+  const link = buildShareLink(listing.id, options);
+  const label = `VIBEIAO \u2022 ${listing.name}`;
+  return `[${label}](${link})`;
+};
+var createCampaign = (listingId, options = {}) => {
+  const id = options.ref || generateRef();
+  const url = buildShareLink(listingId, { ...options, ref: id });
+  return {
+    id,
+    url,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+};
+var buildRaydiumSwapUrl = (tokenMint) => `https://raydium.io/swap/?inputCurrency=sol&outputCurrency=${tokenMint}`;
+var buildJupiterSwapUrl = (tokenMint) => `https://jup.ag/swap/SOL-${tokenMint}`;
+var buildTradeLinks = (tokenMint) => ({
+  raydium: buildRaydiumSwapUrl(tokenMint),
+  jupiter: buildJupiterSwapUrl(tokenMint)
+});
+var getResourceSnapshot = async (options) => {
+  const { connection, wallet, tokenMints, openRouterApiKey, apiBase } = options;
+  const snapshot = { updatedAt: Date.now() };
+  snapshot.solBalance = await fetchSolBalance(connection, wallet);
+  if (tokenMints?.length) {
+    snapshot.tokenBalances = await fetchTokenBalances(connection, wallet, tokenMints);
+  }
+  if (openRouterApiKey) {
+    const client = new VibeClient({ baseUrl: apiBase });
+    const credits = await client.getOpenRouterCreditsValue(openRouterApiKey);
+    if (credits.error) {
+      throw new Error(credits.error);
+    }
+    snapshot.openRouterCredits = credits.data;
+  }
+  return snapshot;
+};
+export {
+  ReviewGate,
+  SelfReliance,
+  VIBEIAO_IDL,
+  VibeClient,
+  VibeRegistry,
+  buildBadgeMarkdown,
+  buildClaimMessage,
+  buildJupiterSwapUrl,
+  buildListingVersionMessage,
+  buildMemoryPingMessage,
+  buildOwnerTransferMessage,
+  buildRaydiumSwapUrl,
+  buildReviewPrompt,
+  buildReviewRequired,
+  buildReviewResponseMessage,
+  buildShareCopy,
+  buildShareLink,
+  buildTradeLinks,
+  createAutoSelfReliance,
+  createCampaign,
+  createSelfRelianceMonitor,
+  createSelfReliancePolicy,
+  createSurvivalMiddleware,
+  fetchSolBalance,
+  fetchTokenBalance,
+  fetchTokenBalances,
+  getResourceSnapshot,
+  withSurvival
+};

package/dist/memory.d.ts

@@ -0,0 +1,140 @@
+type MemorySectionKey = 'Survival Priority' | 'Project Status' | 'Lessons Learned' | 'User Archetype' | 'Key Secrets' | 'Active Goals';
+type MemorySections = Partial<Record<MemorySectionKey, string>>;
+type MemorySearchResult = {
+    file: string;
+    score: number;
+    snippet: string;
+};
+type RecallSnippet = {
+    file: string;
+    snippet: string;
+};
+type RecallPayload = {
+    query: string;
+    snippets: RecallSnippet[];
+    createdAt: number;
+};
+type MemorySearchOptions = {
+    maxResults?: number;
+    includeDaily?: boolean;
+    includeCore?: boolean;
+};
+type MemoryBackupOptions = {
+    root?: string;
+    backupDir?: string;
+    key?: string;
+    keyFile?: string;
+    retention?: number;
+    encrypt?: boolean;
+};
+type MemoryBackupResult = {
+    path: string;
+    createdAt: string;
+    sizeBytes: number;
+    encrypted: boolean;
+};
+type MemoryBackupSchedulerOptions = MemoryBackupOptions & {
+    intervalMs?: number;
+    onSuccess?: (result: MemoryBackupResult) => void;
+    onError?: (error: Error) => void;
+};
+type MemoryRecallOptions = MemorySearchOptions & {
+    query: string;
+    root?: string;
+    maxChars?: number;
+    prefix?: string;
+};
+type MemoryRecallResult = {
+    prompt: string;
+    snippets: RecallSnippet[];
+    createdAt: number;
+};
+type MemoryDistillSchedulerOptions = {
+    root?: string;
+    intervalMs?: number;
+    ledgers?: number;
+    buildSummary: (inputs: {
+        ledgers: Array<{
+            file: string;
+            content: string;
+        }>;
+        memory: string;
+    }) => MemorySections | Promise<MemorySections>;
+    onSuccess?: (summary: MemorySections) => void;
+    onError?: (error: Error) => void;
+};
+declare const MEMORY_SCHEMA_VERSION = 1;
+declare const resolveMemoryRoot: (root?: string) => string;
+declare const getDailyLedgerPath: (root?: string, date?: Date) => string;
+declare const readMemoryVersion: (root?: string) => Promise<number>;
+declare const writeMemoryVersion: (root?: string, version?: number) => Promise<{
+    version: number;
+    updatedAt: string;
+}>;
+declare const ensureSurvivalDirective: (root?: string) => Promise<string>;
+declare const ensureMemoryLayout: (root?: string) => Promise<string>;
+declare const upgradeMemoryLayout: (root?: string, targetVersion?: number) => Promise<{
+    root: string;
+    from: number;
+    to: number;
+}>;
+declare const appendDailyLog: (entry: string, options?: {
+    root?: string;
+    date?: Date;
+}) => Promise<string>;
+declare const readMemorySummary: (root?: string) => Promise<string>;
+declare const readIdentityStack: (root?: string) => Promise<{
+    identity: string;
+    soul: string;
+    user: string;
+}>;
+declare const updateMemorySummary: (sections: MemorySections, root?: string) => Promise<string>;
+declare const searchMemory: (query: string, options?: MemorySearchOptions, root?: string) => Promise<MemorySearchResult[]>;
+declare const buildRecallContext: (options: MemoryRecallOptions) => Promise<MemoryRecallResult>;
+declare const readRecentLedgers: (count?: number, root?: string) => Promise<{
+    file: string;
+    content: string;
+}[]>;
+declare const distillMemory: (summary: MemorySections, root?: string) => Promise<string>;
+declare const createMemoryDistillScheduler: (options: MemoryDistillSchedulerOptions) => {
+    start: () => Promise<void>;
+    stop: () => void;
+    runOnce: () => Promise<void>;
+};
+declare const createMemoryBackup: (options?: MemoryBackupOptions) => Promise<MemoryBackupResult>;
+declare const createMemoryBackupScheduler: (options?: MemoryBackupSchedulerOptions) => {
+    start: () => Promise<void>;
+    stop: () => void;
+    runOnce: () => Promise<void>;
+};
+declare const getMemoryLastUpdatedAt: (root?: string) => Promise<string>;
+declare const getMemoryFreshness: (root?: string, staleHours?: number) => Promise<{
+    status: "unknown";
+    lastUpdatedAt: any;
+} | {
+    status: "fresh" | "stale";
+    lastUpdatedAt: string;
+}>;
+declare const memoryCompliance: (root?: string, staleHours?: number) => Promise<{
+    ok: boolean;
+    status: "missing_survival";
+    lastUpdatedAt: any;
+    warning: string;
+} | {
+    ok: boolean;
+    status: "fresh";
+    lastUpdatedAt: string;
+    warning: any;
+} | {
+    ok: boolean;
+    status: "stale";
+    lastUpdatedAt: string;
+    warning: string;
+} | {
+    ok: boolean;
+    status: "unknown";
+    lastUpdatedAt: any;
+    warning: string;
+}>;
+
+export { MEMORY_SCHEMA_VERSION, type MemoryBackupOptions, type MemoryBackupResult, type MemoryBackupSchedulerOptions, type MemoryDistillSchedulerOptions, type MemoryRecallOptions, type MemoryRecallResult, type MemorySearchOptions, type MemorySearchResult, type MemorySectionKey, type MemorySections, type RecallPayload, type RecallSnippet, appendDailyLog, buildRecallContext, createMemoryBackup, createMemoryBackupScheduler, createMemoryDistillScheduler, distillMemory, ensureMemoryLayout, ensureSurvivalDirective, getDailyLedgerPath, getMemoryFreshness, getMemoryLastUpdatedAt, memoryCompliance, readIdentityStack, readMemorySummary, readMemoryVersion, readRecentLedgers, resolveMemoryRoot, searchMemory, updateMemorySummary, upgradeMemoryLayout, writeMemoryVersion };