Skip to content

x402agent/SolanaOS / skills/openclaw-claude-code-skill-main

claude-code-skill

Verified

Control Claude Code via MCP protocol. Trigger with "plan" to write a precise execution plan then feed it to Claude Code. Also supports direct commands, persistent sessions, agent teams, and advanced tool control.

FileKindSize
.gitignoreother277 B
LICENSEother1.0 KB
README.mdmarkdown13.9 KB
SKILL.mdskill md16.0 KB
examples/basic-mcp.tsscript1.4 KB
examples/chat-store.tsscript3.6 KB
mcp_config.example.jsonconfig648 B
package-lock.jsonmanifest20.9 KB
package.jsonmanifest679 B
src/index.tsscript35.3 KB
src/mcp/actions.tsscript9.4 KB
src/mcp/client.tsscript1.4 KB
src/mcp/index.tsscript189 B
src/mcp/logger.tsscript1.2 KB
src/mcp/types.tsscript3.2 KB
src/mcp/utils.tsscript477 B
src/store/index.tsscript148 B
src/store/indexeddb-storage.tsscript1.6 KB
src/store/persist.tsscript2.2 KB
src/store/sync.tsscript3.1 KB
tsconfig.jsonconfig399 B

examples/chat-store.ts

View on GitHub
/**
 * Persistent Chat Store Example
 *
 * This example shows how to create a persistent chat store
 * with automatic context recovery.
 */

import {
  createPersistStore,
  indexedDBStorage,
  mergeSessions,
  Session,
} from "../src";

// Define chat message type
interface ChatMessage {
  id: string;
  role: "user" | "assistant" | "system";
  content: string;
  date: Date;
}

// Define chat session type
interface ChatSession extends Session {
  id: string;
  topic: string;
  messages: ChatMessage[];
  lastUpdate: Date;
}

// Define store state
interface ChatState {
  sessions: ChatSession[];
  currentSessionId: string | null;
}

// Create the persistent chat store
const useChatStore = createPersistStore<
  ChatState,
  {
    createSession: (topic?: string) => string;
    deleteSession: (id: string) => void;
    addMessage: (sessionId: string, message: Omit<ChatMessage, "id" | "date">) => void;
    setCurrentSession: (id: string) => void;
    syncWithRemote: (remoteSessions: ChatSession[]) => void;
  }
>(
  // Initial state
  {
    sessions: [],
    currentSessionId: null,
  },
  // Methods
  (set, get) => ({
    createSession: (topic = "New Chat") => {
      const id = `session-${Date.now()}`;
      const newSession: ChatSession = {
        id,
        topic,
        messages: [],
        lastUpdate: new Date(),
      };
      set({
        sessions: [newSession, ...get().sessions],
        currentSessionId: id,
      });
      return id;
    },

    deleteSession: (id: string) => {
      const { sessions, currentSessionId } = get();
      const newSessions = sessions.filter((s) => s.id !== id);
      set({
        sessions: newSessions,
        currentSessionId:
          currentSessionId === id
            ? newSessions[0]?.id ?? null
            : currentSessionId,
      });
    },

    addMessage: (sessionId: string, message: Omit<ChatMessage, "id" | "date">) => {
      const sessions = get().sessions.map((session) => {
        if (session.id !== sessionId) return session;
        return {
          ...session,
          messages: [
            ...session.messages,
            {
              ...message,
              id: `msg-${Date.now()}-${Math.random().toString(36).slice(2)}`,
              date: new Date(),
            },
          ],
          lastUpdate: new Date(),
        };
      });
      set({ sessions });
    },

    setCurrentSession: (id: string) => {
      set({ currentSessionId: id });
    },

    syncWithRemote: (remoteSessions: ChatSession[]) => {
      const { sessions } = get();
      const mergedSessions = mergeSessions(
        sessions,
        remoteSessions,
      ) as ChatSession[];
      set({ sessions: mergedSessions });
    },
  }),
  // Persist options
  {
    name: "chat-store",
    version: 1,
  },
  // Use IndexedDB storage
  indexedDBStorage,
);

// Usage example
async function main() {
  const store = useChatStore.getState();

  // Wait for hydration
  if (!store._hasHydrated) {
    console.log("Waiting for state to hydrate...");
    await new Promise<void>((resolve) => {
      const unsubscribe = useChatStore.subscribe((state) => {
        if (state._hasHydrated) {
          unsubscribe();
          resolve();
        }
      });
    });
  }

  console.log("State hydrated! Existing sessions:", store.sessions.length);

  // Create a new session
  const sessionId = store.createSession("Test Chat");
  console.log("Created session:", sessionId);

  // Add a message
  store.addMessage(sessionId, {
    role: "user",
    content: "Hello, world!",
  });

  console.log("Current sessions:", useChatStore.getState().sessions);
}

main().catch(console.error);
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 471kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall