@stacknet/stacks 0.2.0 → 0.2.2

package/src/clients/skills.ts

@@ -1,236 +0,0 @@
-/**
- * Skills Client
- *
- * Client for interacting with the Skills API via the Agent Coprocessor
- */
-
-import { DEFAULT_MAGMA_RPC_URL } from '../utils/constants';
-import type {
-  Skill,
-  SkillsListResponse,
-  SkillResponse,
-  SkillCreateInput,
-  SkillUpdateInput,
-  SkillsClientConfig,
-  SkillVerifyResponse,
-  SkillMapResponse,
-  SkillMapPromptResponse,
-  SkillSummaryResponse,
-} from '../types/skill';
-
-export type { SkillsClientConfig };
-
-export class SkillsClient {
-  private baseUrl: string;
-  private useCpxApi: boolean;
-
-  constructor(config: SkillsClientConfig = {}) {
-    this.baseUrl = config.baseUrl || DEFAULT_MAGMA_RPC_URL;
-    // Use coprocessor API by default (can be disabled for backwards compatibility)
-    this.useCpxApi = config.useCpxApi !== false;
-  }
-
-  private get skillsUrl(): string {
-    // Route through Agent Coprocessor at /cpx/agent/skills
-    return this.useCpxApi
-      ? `${this.baseUrl}/cpx/agent/skills`
-      : `${this.baseUrl}/skills`;
-  }
-
-  /**
-   * List skills
-   */
-  async list(options?: {
-    scope?: 'public' | 'private' | 'all';
-    creatorMid?: string;
-    contentType?: 'code' | 'text' | 'image' | 'video' | 'music' | string;
-    precompiled?: boolean;
-  }): Promise<SkillsListResponse> {
-    const params = new URLSearchParams();
-
-    // Precompiled filter takes priority
-    if (options?.precompiled) {
-      params.set('precompiled', 'true');
-      if (options?.contentType) {
-        params.set('content_type', options.contentType);
-      }
-    } else if (options?.contentType) {
-      params.set('content_type', options.contentType);
-    } else if (options?.creatorMid) {
-      params.set('creator_mid', options.creatorMid);
-    } else if (options?.scope && options.scope !== 'all') {
-      params.set('scope', options.scope);
-    }
-
-    const url = params.toString()
-      ? `${this.skillsUrl}?${params.toString()}`
-      : this.skillsUrl;
-
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`Failed to list skills: ${response.statusText}`);
-    }
-    return response.json();
-  }
-
-  /**
-   * Get a skill by ID
-   */
-  async get(id: string): Promise<Skill> {
-    const response = await fetch(`${this.skillsUrl}/${id}`);
-    if (!response.ok) {
-      throw new Error(`Skill not found: ${id}`);
-    }
-    return response.json();
-  }
-
-  /**
-   * Create a new skill
-   */
-  async create(skill: SkillCreateInput): Promise<SkillResponse> {
-    const response = await fetch(this.skillsUrl, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(skill),
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({}));
-      throw new Error(error.error || `Failed to create skill: ${response.statusText}`);
-    }
-    return response.json();
-  }
-
-  /**
-   * Update a skill
-   */
-  async update(id: string, updates: SkillUpdateInput): Promise<SkillResponse> {
-    const response = await fetch(`${this.skillsUrl}/${id}`, {
-      method: 'PUT',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(updates),
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({}));
-      throw new Error(error.error || `Failed to update skill: ${response.statusText}`);
-    }
-    return response.json();
-  }
-
-  /**
-   * Delete a skill
-   */
-  async delete(id: string): Promise<SkillResponse> {
-    const response = await fetch(`${this.skillsUrl}/${id}`, {
-      method: 'DELETE',
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({}));
-      throw new Error(error.error || `Failed to delete skill: ${response.statusText}`);
-    }
-    return response.json();
-  }
-
-  /**
-   * Track skill usage
-   */
-  async trackUsage(id: string): Promise<void> {
-    try {
-      await fetch(`${this.skillsUrl}/${id}/usage`, {
-        method: 'POST',
-      });
-    } catch {
-      // Silently ignore usage tracking errors
-    }
-  }
-
-  /**
-   * Verify skill hash integrity
-   */
-  async verify(id: string): Promise<SkillVerifyResponse> {
-    const response = await fetch(`${this.skillsUrl}/${id}/verify`);
-    if (!response.ok) {
-      throw new Error(`Failed to verify skill: ${response.statusText}`);
-    }
-    return response.json();
-  }
-
-  /**
-   * Rehash a skill (recompute its hash)
-   */
-  async rehash(id: string): Promise<{ skillId: string; hash: string | null }> {
-    const response = await fetch(`${this.skillsUrl}/${id}/rehash`, {
-      method: 'POST',
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to rehash skill: ${response.statusText}`);
-    }
-    return response.json();
-  }
-
-  /**
-   * Rehash all skills
-   */
-  async rehashAll(): Promise<{ updated: number; total: number }> {
-    const response = await fetch(`${this.skillsUrl}/rehash-all`, {
-      method: 'POST',
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to rehash all skills: ${response.statusText}`);
-    }
-    return response.json();
-  }
-
-  /**
-   * Get skill map (JSON format)
-   */
-  async getMap(contentType?: string): Promise<SkillMapResponse> {
-    const params = contentType ? `?content_type=${contentType}` : '';
-    const response = await fetch(`${this.skillsUrl}/map${params}`);
-    if (!response.ok) {
-      throw new Error(`Failed to get skill map: ${response.statusText}`);
-    }
-    return response.json();
-  }
-
-  /**
-   * Get skill map as system prompt
-   */
-  async getMapPrompt(contentType?: string): Promise<SkillMapPromptResponse> {
-    const params = contentType ? `?content_type=${contentType}` : '';
-    const response = await fetch(`${this.skillsUrl}/map/prompt${params}`);
-    if (!response.ok) {
-      throw new Error(`Failed to get skill map prompt: ${response.statusText}`);
-    }
-    return response.json();
-  }
-
-  /**
-   * Get non-code skill map prompt
-   */
-  async getNonCodeMap(): Promise<SkillMapPromptResponse> {
-    const response = await fetch(`${this.skillsUrl}/map/noncode`);
-    if (!response.ok) {
-      throw new Error(`Failed to get non-code skill map: ${response.statusText}`);
-    }
-    return response.json();
-  }
-
-  /**
-   * Get non-code skill summary
-   */
-  async getNonCodeSummary(): Promise<SkillSummaryResponse> {
-    const response = await fetch(`${this.skillsUrl}/summary/noncode`);
-    if (!response.ok) {
-      throw new Error(`Failed to get non-code skill summary: ${response.statusText}`);
-    }
-    return response.json();
-  }
-}
-
-// Factory function
-export function createSkillsClient(config?: SkillsClientConfig): SkillsClient {
-  return new SkillsClient(config);
-}
-
-// Default instance
-export const skillsClient = createSkillsClient();

package/src/clients/social.ts

@@ -1,286 +0,0 @@
-/**
- * Social Network Client
- * Client for interacting with the P2P social network API
- */
-
-import { DEFAULT_TASK_NETWORK_URL, JSON_HEADERS } from '../utils/constants';
-import { StacksSDKError } from '../utils/errors';
-import type {
-  SocialClientConfig,
-  FeedResponse,
-  PostResponse,
-  CommentsResponse,
-  RemixesResponse,
-  LikeCheckResponse,
-  LikeResponse,
-  CommentResponse,
-  CreatePostInput,
-  CreatePostResponse,
-  ProfileResponse,
-  MediaType,
-} from '../types/social';
-
-export type { SocialClientConfig } from '../types/social';
-
-export class SocialClient {
-  private baseUrl: string;
-
-  constructor(config: SocialClientConfig = {}) {
-    this.baseUrl = config.baseUrl || DEFAULT_TASK_NETWORK_URL;
-  }
-
-  private get socialUrl(): string {
-    return `${this.baseUrl}/social`;
-  }
-
-  /**
-   * Fetch feed with pagination
-   */
-  async getFeed(options: {
-    page?: number;
-    limit?: number;
-    mediaType?: MediaType;
-  } = {}): Promise<FeedResponse> {
-    const { page = 1, limit = 10, mediaType } = options;
-
-    const params = new URLSearchParams({
-      page: String(page),
-      limit: String(limit),
-    });
-
-    if (mediaType) {
-      params.set('media_type', mediaType);
-    }
-
-    const response = await fetch(`${this.socialUrl}/feed?${params}`);
-
-    if (!response.ok) {
-      throw new StacksSDKError(
-        'bad_request:api',
-        `Failed to fetch feed: ${response.statusText}`
-      );
-    }
-
-    return response.json();
-  }
-
-  /**
-   * Fetch a single post by ID
-   */
-  async getPost(postId: string): Promise<PostResponse> {
-    const response = await fetch(`${this.socialUrl}/posts/${postId}`);
-
-    if (!response.ok) {
-      throw new StacksSDKError(
-        response.status === 404 ? 'not_found:api' : 'bad_request:api',
-        `Failed to fetch post: ${response.statusText}`
-      );
-    }
-
-    return response.json();
-  }
-
-  /**
-   * Fetch comments for a post
-   */
-  async getComments(postId: string): Promise<CommentsResponse> {
-    const response = await fetch(`${this.socialUrl}/posts/${postId}/comments`);
-
-    if (!response.ok) {
-      throw new StacksSDKError(
-        'bad_request:api',
-        `Failed to fetch comments: ${response.statusText}`
-      );
-    }
-
-    return response.json();
-  }
-
-  /**
-   * Fetch remixes for a post
-   */
-  async getRemixes(postId: string): Promise<RemixesResponse> {
-    const response = await fetch(`${this.socialUrl}/posts/${postId}/remixes`);
-
-    if (!response.ok) {
-      throw new StacksSDKError(
-        'bad_request:api',
-        `Failed to fetch remixes: ${response.statusText}`
-      );
-    }
-
-    return response.json();
-  }
-
-  /**
-   * Check if a user has liked a post
-   */
-  async checkLike(postId: string, userMid: string): Promise<LikeCheckResponse> {
-    const response = await fetch(
-      `${this.socialUrl}/posts/${postId}/likes/check?userMid=${encodeURIComponent(userMid)}`
-    );
-
-    if (!response.ok) {
-      throw new StacksSDKError(
-        'bad_request:api',
-        `Failed to check like status: ${response.statusText}`
-      );
-    }
-
-    return response.json();
-  }
-
-  /**
-   * Like a post
-   */
-  async likePost(postId: string, userMid: string): Promise<LikeResponse> {
-    const response = await fetch(`${this.socialUrl}/like`, {
-      method: 'POST',
-      headers: JSON_HEADERS,
-      body: JSON.stringify({ postId, userMid }),
-    });
-
-    if (!response.ok) {
-      throw new StacksSDKError(
-        'bad_request:api',
-        `Failed to like post: ${response.statusText}`
-      );
-    }
-
-    return response.json();
-  }
-
-  /**
-   * Unlike a post
-   */
-  async unlikePost(postId: string, userMid: string): Promise<LikeResponse> {
-    const response = await fetch(`${this.socialUrl}/unlike`, {
-      method: 'POST',
-      headers: JSON_HEADERS,
-      body: JSON.stringify({ postId, userMid }),
-    });
-
-    if (!response.ok) {
-      throw new StacksSDKError(
-        'bad_request:api',
-        `Failed to unlike post: ${response.statusText}`
-      );
-    }
-
-    return response.json();
-  }
-
-  /**
-   * Add a comment to a post
-   */
-  async addComment(
-    postId: string,
-    userMid: string,
-    content: string
-  ): Promise<CommentResponse> {
-    const response = await fetch(`${this.socialUrl}/comment`, {
-      method: 'POST',
-      headers: JSON_HEADERS,
-      body: JSON.stringify({ postId, userMid, content }),
-    });
-
-    if (!response.ok) {
-      throw new StacksSDKError(
-        'bad_request:api',
-        `Failed to add comment: ${response.statusText}`
-      );
-    }
-
-    return response.json();
-  }
-
-  /**
-   * Create a new post
-   */
-  async createPost(input: CreatePostInput): Promise<CreatePostResponse> {
-    const response = await fetch(`${this.socialUrl}/post`, {
-      method: 'POST',
-      headers: JSON_HEADERS,
-      body: JSON.stringify({
-        userMid: input.creatorMid,
-        content: input.content,
-        mediaUrl: input.mediaUrl,
-        mediaType: input.mediaType,
-        orientation: input.orientation,
-        posterUrl: input.posterUrl,
-        remixOf: input.remixOf,
-      }),
-    });
-
-    if (!response.ok) {
-      throw new StacksSDKError(
-        'bad_request:api',
-        `Failed to create post: ${response.statusText}`
-      );
-    }
-
-    return response.json();
-  }
-
-  /**
-   * Track a view on a post
-   */
-  async trackView(postId: string, userMid?: string): Promise<void> {
-    await fetch(`${this.socialUrl}/posts/${postId}/view`, {
-      method: 'POST',
-      headers: JSON_HEADERS,
-      body: JSON.stringify({ userMid }),
-    }).catch(() => {
-      // Silently fail view tracking
-    });
-  }
-
-  /**
-   * Track a play on audio/video post
-   */
-  async trackPlay(postId: string, userMid?: string): Promise<void> {
-    await fetch(`${this.socialUrl}/posts/${postId}/play`, {
-      method: 'POST',
-      headers: JSON_HEADERS,
-      body: JSON.stringify({ userMid }),
-    }).catch(() => {
-      // Silently fail play tracking
-    });
-  }
-
-  /**
-   * Get user profile by MID
-   */
-  async getProfile(mid: string): Promise<ProfileResponse | null> {
-    try {
-      const response = await fetch(`${this.socialUrl}/profile/${mid}`);
-
-      if (!response.ok) {
-        if (response.status === 404) {
-          return null;
-        }
-        throw new StacksSDKError(
-          'bad_request:api',
-          `Failed to fetch profile: ${response.statusText}`
-        );
-      }
-
-      return response.json();
-    } catch (error) {
-      if (error instanceof StacksSDKError) throw error;
-      return null;
-    }
-  }
-}
-
-/**
- * Create a SocialClient instance
- */
-export function createSocialClient(config: SocialClientConfig = {}): SocialClient {
-  return new SocialClient(config);
-}
-
-/**
- * Default social client instance
- */
-export const socialClient = createSocialClient();