@oro.ad/nuxt-claude-devtools 1.0.6 → 1.1.0

package/dist/runtime/server/commands-manager.js

@@ -0,0 +1,132 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { createLogger } from "../logger.js";
+const log = createLogger("commands", { timestamp: true });
+export class CommandsManager {
+  commandsDir;
+  constructor(projectPath) {
+    this.commandsDir = join(projectPath, ".claude", "commands");
+    if (!existsSync(this.commandsDir)) {
+      mkdirSync(this.commandsDir, { recursive: true });
+      log("Created commands directory", { path: this.commandsDir });
+    }
+  }
+  // Parse frontmatter from markdown content
+  parseFrontmatter(content) {
+    const frontmatterRegex = /^---\n((?:[^\n]*\n)*?)---\n([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (!match) {
+      return { frontmatter: {}, body: content };
+    }
+    const [, yaml, body] = match;
+    const frontmatter = {};
+    for (const line of yaml.split("\n")) {
+      const colonIndex = line.indexOf(":");
+      if (colonIndex === -1) continue;
+      const key = line.slice(0, colonIndex).trim();
+      const value = line.slice(colonIndex + 1).trim();
+      if (key === "description") {
+        frontmatter.description = value;
+      } else if (key === "allowed-tools") {
+        frontmatter["allowed-tools"] = value;
+      } else if (key === "disable-model-invocation") {
+        frontmatter["disable-model-invocation"] = value === "true";
+      }
+    }
+    return { frontmatter, body: body.trim() };
+  }
+  // Build frontmatter string
+  buildFrontmatter(command) {
+    const lines = ["---"];
+    if (command.description) {
+      lines.push(`description: ${command.description}`);
+    }
+    if (command.allowedTools && command.allowedTools.length > 0) {
+      lines.push(`allowed-tools: ${command.allowedTools.join(", ")}`);
+    }
+    if (command.disableModelInvocation !== void 0) {
+      lines.push(`disable-model-invocation: ${command.disableModelInvocation}`);
+    }
+    lines.push("---");
+    return lines.join("\n");
+  }
+  // Get all slash commands
+  getCommands() {
+    const commands = [];
+    if (!existsSync(this.commandsDir)) return commands;
+    const entries = readdirSync(this.commandsDir);
+    for (const entry of entries) {
+      if (!entry.endsWith(".md")) continue;
+      const fullPath = join(this.commandsDir, entry);
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) continue;
+      const rawContent = readFileSync(fullPath, "utf-8");
+      const { frontmatter, body } = this.parseFrontmatter(rawContent);
+      commands.push({
+        name: basename(entry, ".md"),
+        path: entry,
+        description: frontmatter.description,
+        allowedTools: frontmatter["allowed-tools"] ? frontmatter["allowed-tools"].split(",").map((s) => s.trim()) : void 0,
+        disableModelInvocation: frontmatter["disable-model-invocation"],
+        content: body,
+        rawContent,
+        updatedAt: stat.mtime.toISOString()
+      });
+    }
+    return commands.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  // Get single command
+  getCommand(name) {
+    const fileName = name.endsWith(".md") ? name : `${name}.md`;
+    const fullPath = join(this.commandsDir, fileName);
+    if (!existsSync(fullPath)) return null;
+    const stat = statSync(fullPath);
+    const rawContent = readFileSync(fullPath, "utf-8");
+    const { frontmatter, body } = this.parseFrontmatter(rawContent);
+    return {
+      name: basename(fileName, ".md"),
+      path: fileName,
+      description: frontmatter.description,
+      allowedTools: frontmatter["allowed-tools"] ? frontmatter["allowed-tools"].split(",").map((s) => s.trim()) : void 0,
+      disableModelInvocation: frontmatter["disable-model-invocation"],
+      content: body,
+      rawContent,
+      updatedAt: stat.mtime.toISOString()
+    };
+  }
+  // Create or update command
+  saveCommand(name, content, options) {
+    const safeName = name.replace(/[^\w-]/g, "-").toLowerCase();
+    const fileName = `${safeName}.md`;
+    const fullPath = join(this.commandsDir, fileName);
+    const frontmatter = this.buildFrontmatter({
+      description: options?.description,
+      allowedTools: options?.allowedTools,
+      disableModelInvocation: options?.disableModelInvocation
+    });
+    const rawContent = `${frontmatter}
+
+${content}`;
+    writeFileSync(fullPath, rawContent, "utf-8");
+    log("Saved command", { name: safeName });
+    return {
+      name: safeName,
+      path: fileName,
+      description: options?.description,
+      allowedTools: options?.allowedTools,
+      disableModelInvocation: options?.disableModelInvocation,
+      content,
+      rawContent,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  // Delete command
+  deleteCommand(name) {
+    const fileName = name.endsWith(".md") ? name : `${name}.md`;
+    const fullPath = join(this.commandsDir, fileName);
+    if (!existsSync(fullPath)) return false;
+    unlinkSync(fullPath);
+    log("Deleted command", { name });
+    return true;
+  }
+}

package/dist/runtime/server/docs-manager.d.ts

@@ -0,0 +1,48 @@
+export interface DocFile {
+    path: string;
+    name: string;
+    content: string;
+    updatedAt: string;
+}
+export interface LlmsSource {
+    url: string;
+    domain: string;
+    title?: string;
+    description?: string;
+    addedAt: string;
+}
+export interface LlmsStore {
+    version: 1;
+    sources: LlmsSource[];
+}
+export declare class DocsManager {
+    private docsDir;
+    private llmsPath;
+    private projectPath;
+    constructor(projectPath: string);
+    getDocFiles(): DocFile[];
+    private scanDirectory;
+    getDocFile(relativePath: string): DocFile | null;
+    saveDocFile(relativePath: string, content: string): DocFile;
+    deleteDocFile(relativePath: string): boolean;
+    private get claudeMdPath();
+    getClaudeMd(): {
+        content: string;
+        exists: boolean;
+        updatedAt: string | null;
+    };
+    saveClaudeMd(content: string): {
+        content: string;
+        exists: boolean;
+        updatedAt: string;
+    };
+    private loadLlmsStore;
+    private saveLlmsStore;
+    getLlmsSources(): LlmsSource[];
+    addLlmsSource(url: string, title?: string, description?: string): LlmsSource;
+    removeLlmsSource(url: string): boolean;
+    updateLlmsSource(url: string, updates: {
+        title?: string;
+        description?: string;
+    }): LlmsSource | null;
+}

package/dist/runtime/server/docs-manager.js

@@ -0,0 +1,189 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative } from "node:path";
+import { createLogger } from "../logger.js";
+const log = createLogger("docs", { timestamp: true });
+export class DocsManager {
+  docsDir;
+  llmsPath;
+  projectPath;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.docsDir = join(projectPath, ".claude", "docs");
+    this.llmsPath = join(projectPath, ".claude-devtools", "llms.json");
+    if (!existsSync(this.docsDir)) {
+      mkdirSync(this.docsDir, { recursive: true });
+      log("Created docs directory", { path: this.docsDir });
+    }
+  }
+  // ============ Doc Files ============
+  // Get all doc files recursively
+  getDocFiles() {
+    const files = [];
+    this.scanDirectory(this.docsDir, files);
+    return files.sort((a, b) => a.path.localeCompare(b.path));
+  }
+  scanDirectory(dir, files) {
+    if (!existsSync(dir)) return;
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      const fullPath = join(dir, entry);
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) {
+        this.scanDirectory(fullPath, files);
+      } else if (entry.endsWith(".md")) {
+        const relativePath = relative(this.docsDir, fullPath);
+        const content = readFileSync(fullPath, "utf-8");
+        files.push({
+          path: relativePath,
+          name: basename(entry, ".md"),
+          content,
+          updatedAt: stat.mtime.toISOString()
+        });
+      }
+    }
+  }
+  // Get single doc file
+  getDocFile(relativePath) {
+    const fullPath = join(this.docsDir, relativePath);
+    if (!existsSync(fullPath)) return null;
+    const stat = statSync(fullPath);
+    const content = readFileSync(fullPath, "utf-8");
+    return {
+      path: relativePath,
+      name: basename(relativePath, ".md"),
+      content,
+      updatedAt: stat.mtime.toISOString()
+    };
+  }
+  // Create or update doc file
+  saveDocFile(relativePath, content) {
+    if (!relativePath.endsWith(".md")) {
+      relativePath += ".md";
+    }
+    const fullPath = join(this.docsDir, relativePath);
+    const dir = dirname(fullPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(fullPath, content, "utf-8");
+    log("Saved doc file", { path: relativePath });
+    return {
+      path: relativePath,
+      name: basename(relativePath, ".md"),
+      content,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  // Delete doc file
+  deleteDocFile(relativePath) {
+    const fullPath = join(this.docsDir, relativePath);
+    if (!existsSync(fullPath)) return false;
+    unlinkSync(fullPath);
+    log("Deleted doc file", { path: relativePath });
+    return true;
+  }
+  // ============ CLAUDE.md ============
+  get claudeMdPath() {
+    return join(this.projectPath, "CLAUDE.md");
+  }
+  // Get CLAUDE.md content
+  getClaudeMd() {
+    const path = this.claudeMdPath;
+    if (!existsSync(path)) {
+      return { content: "", exists: false, updatedAt: null };
+    }
+    const stat = statSync(path);
+    const content = readFileSync(path, "utf-8");
+    return {
+      content,
+      exists: true,
+      updatedAt: stat.mtime.toISOString()
+    };
+  }
+  // Save CLAUDE.md content
+  saveClaudeMd(content) {
+    writeFileSync(this.claudeMdPath, content, "utf-8");
+    log("Saved CLAUDE.md");
+    return {
+      content,
+      exists: true,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  // ============ LLMS Sources ============
+  loadLlmsStore() {
+    try {
+      if (existsSync(this.llmsPath)) {
+        const data = readFileSync(this.llmsPath, "utf-8");
+        return JSON.parse(data);
+      }
+    } catch (error) {
+      log("Failed to load llms store", { error });
+    }
+    return {
+      version: 1,
+      sources: []
+    };
+  }
+  saveLlmsStore(store) {
+    const dir = dirname(this.llmsPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(this.llmsPath, JSON.stringify(store, null, 2));
+    log("Saved llms store");
+  }
+  // Get all LLMS sources
+  getLlmsSources() {
+    return this.loadLlmsStore().sources;
+  }
+  // Add LLMS source
+  addLlmsSource(url, title, description) {
+    const store = this.loadLlmsStore();
+    let domain;
+    try {
+      const urlObj = new URL(url);
+      domain = urlObj.hostname;
+    } catch {
+      domain = url.replace(/^https?:\/\//, "").split("/")[0];
+    }
+    const existing = store.sources.find((s) => s.url === url);
+    if (existing) {
+      existing.title = title || existing.title;
+      existing.description = description || existing.description;
+      this.saveLlmsStore(store);
+      return existing;
+    }
+    const source = {
+      url,
+      domain,
+      title,
+      description,
+      addedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    store.sources.push(source);
+    this.saveLlmsStore(store);
+    log("Added LLMS source", { url, domain });
+    return source;
+  }
+  // Remove LLMS source
+  removeLlmsSource(url) {
+    const store = this.loadLlmsStore();
+    const index = store.sources.findIndex((s) => s.url === url);
+    if (index === -1) return false;
+    store.sources.splice(index, 1);
+    this.saveLlmsStore(store);
+    log("Removed LLMS source", { url });
+    return true;
+  }
+  // Update LLMS source metadata
+  updateLlmsSource(url, updates) {
+    const store = this.loadLlmsStore();
+    const source = store.sources.find((s) => s.url === url);
+    if (!source) return null;
+    if (updates.title !== void 0) source.title = updates.title;
+    if (updates.description !== void 0) source.description = updates.description;
+    this.saveLlmsStore(store);
+    return source;
+  }
+}

package/dist/runtime/server/history-manager.d.ts

@@ -0,0 +1,24 @@
+import type { Conversation, Message } from '../types.js';
+export declare class HistoryManager {
+    private storePath;
+    private store;
+    private projectPath;
+    constructor(projectPath: string);
+    private loadStore;
+    private saveStore;
+    private generateId;
+    createConversation(): Conversation;
+    getActiveConversation(): Conversation;
+    addMessage(message: Message): void;
+    updateLastAssistantMessage(updates: Partial<Message>): void;
+    getConversations(): Conversation[];
+    getConversation(id: string): Conversation | undefined;
+    setActiveConversation(id: string): Conversation | undefined;
+    deleteConversation(id: string): boolean;
+    resetSession(): Conversation;
+    getActiveConversationId(): string | null;
+    setClaudeSessionId(sessionId: string): void;
+    getClaudeSessionId(): string | null;
+    formatHistoryForSystemPrompt(): string | null;
+    hasHistoryForRecovery(): boolean;
+}

package/dist/runtime/server/history-manager.js

@@ -0,0 +1,184 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createLogger } from "../logger.js";
+const log = createLogger("history", { timestamp: true });
+export class HistoryManager {
+  storePath;
+  store;
+  projectPath;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    const historyDir = join(projectPath, ".claude-devtools");
+    this.storePath = join(historyDir, "history.json");
+    if (!existsSync(historyDir)) {
+      mkdirSync(historyDir, { recursive: true });
+      log("Created history directory", { path: historyDir });
+    }
+    this.store = this.loadStore();
+  }
+  loadStore() {
+    try {
+      if (existsSync(this.storePath)) {
+        const data = readFileSync(this.storePath, "utf-8");
+        const parsed = JSON.parse(data);
+        log("Loaded history store", { conversations: parsed.conversations.length });
+        return parsed;
+      }
+    } catch (error) {
+      log("Failed to load history store", { error });
+    }
+    return {
+      version: 1,
+      conversations: [],
+      activeConversationId: null
+    };
+  }
+  saveStore() {
+    try {
+      writeFileSync(this.storePath, JSON.stringify(this.store, null, 2));
+      log("Saved history store");
+    } catch (error) {
+      log("Failed to save history store", { error });
+    }
+  }
+  generateId() {
+    return `conv_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  }
+  // Create new conversation
+  createConversation() {
+    const conversation = {
+      id: this.generateId(),
+      messages: [],
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      projectPath: this.projectPath
+    };
+    this.store.conversations.unshift(conversation);
+    this.store.activeConversationId = conversation.id;
+    this.saveStore();
+    log("Created conversation", { id: conversation.id });
+    return conversation;
+  }
+  // Get active conversation or create new one
+  getActiveConversation() {
+    if (this.store.activeConversationId) {
+      const conv = this.store.conversations.find(
+        (c) => c.id === this.store.activeConversationId
+      );
+      if (conv) return conv;
+    }
+    return this.createConversation();
+  }
+  // Add message to active conversation
+  addMessage(message) {
+    const conversation = this.getActiveConversation();
+    conversation.messages.push(message);
+    conversation.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (!conversation.title && message.role === "user") {
+      conversation.title = message.content.substring(0, 50) + (message.content.length > 50 ? "..." : "");
+    }
+    this.saveStore();
+  }
+  // Update last assistant message (for streaming completion)
+  updateLastAssistantMessage(updates) {
+    const conversation = this.getActiveConversation();
+    const lastAssistant = [...conversation.messages].reverse().find((m) => m.role === "assistant");
+    if (lastAssistant) {
+      Object.assign(lastAssistant, updates);
+      conversation.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.saveStore();
+    }
+  }
+  // Get all conversations (for history list)
+  getConversations() {
+    return this.store.conversations;
+  }
+  // Get specific conversation by ID
+  getConversation(id) {
+    return this.store.conversations.find((c) => c.id === id);
+  }
+  // Set active conversation
+  setActiveConversation(id) {
+    const conversation = this.getConversation(id);
+    if (conversation) {
+      this.store.activeConversationId = id;
+      this.saveStore();
+    }
+    return conversation;
+  }
+  // Delete conversation
+  deleteConversation(id) {
+    const index = this.store.conversations.findIndex((c) => c.id === id);
+    if (index !== -1) {
+      this.store.conversations.splice(index, 1);
+      if (this.store.activeConversationId === id) {
+        this.store.activeConversationId = this.store.conversations[0]?.id || null;
+      }
+      this.saveStore();
+      return true;
+    }
+    return false;
+  }
+  // Reset (new conversation)
+  resetSession() {
+    this.store.activeConversationId = null;
+    return this.createConversation();
+  }
+  // Get active conversation ID
+  getActiveConversationId() {
+    return this.store.activeConversationId;
+  }
+  // Set Claude session ID for active conversation (empty string clears it)
+  setClaudeSessionId(sessionId) {
+    const conversation = this.getActiveConversation();
+    if (sessionId) {
+      conversation.claudeSessionId = sessionId;
+    } else {
+      delete conversation.claudeSessionId;
+    }
+    this.saveStore();
+    log("Set Claude session ID", { conversationId: conversation.id, sessionId: sessionId || "(cleared)" });
+  }
+  // Get Claude session ID for active conversation
+  getClaudeSessionId() {
+    const conversation = this.store.activeConversationId ? this.store.conversations.find((c) => c.id === this.store.activeConversationId) : null;
+    return conversation?.claudeSessionId || null;
+  }
+  // Format conversation history for system prompt (fallback when --resume fails)
+  formatHistoryForSystemPrompt() {
+    const conversation = this.store.activeConversationId ? this.store.conversations.find((c) => c.id === this.store.activeConversationId) : null;
+    if (!conversation || conversation.messages.length === 0) {
+      return null;
+    }
+    const lines = [
+      "=== CONVERSATION HISTORY (context recovery) ===",
+      "The following is the history of our previous conversation. Please continue from where we left off.",
+      ""
+    ];
+    for (const msg of conversation.messages) {
+      const role = msg.role === "user" ? "User" : "Assistant";
+      const timestamp = typeof msg.timestamp === "string" ? msg.timestamp : msg.timestamp.toISOString();
+      lines.push(`[${role}] (${timestamp})`);
+      if (msg.role === "assistant") {
+        if (msg.content) {
+          lines.push(msg.content);
+        }
+      } else {
+        lines.push(msg.content);
+      }
+      lines.push("");
+    }
+    lines.push("=== END OF HISTORY ===");
+    lines.push("");
+    log("Formatted history for system prompt", {
+      conversationId: conversation.id,
+      messageCount: conversation.messages.length
+    });
+    return lines.join("\n");
+  }
+  // Check if conversation has history that can be used for context recovery
+  hasHistoryForRecovery() {
+    const conversation = this.store.activeConversationId ? this.store.conversations.find((c) => c.id === this.store.activeConversationId) : null;
+    return !!conversation && conversation.messages.length > 0;
+  }
+}

package/dist/runtime/server/plugins/socket.io.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitropack").NitroAppPlugin;
+export default _default;

package/dist/runtime/server/plugins/socket.io.js

@@ -0,0 +1,48 @@
+import { defineNitroPlugin, useRuntimeConfig } from "nitropack/runtime";
+import { Server as Engine } from "engine.io";
+import { Server } from "socket.io";
+import { defineEventHandler } from "h3";
+import { createLogger } from "../../logger.js";
+import { getClaudeSessionInstance, initClaudeSession } from "../claude-session.js";
+const log = createLogger("plugin");
+export default defineNitroPlugin((nitroApp) => {
+  const config = useRuntimeConfig();
+  const claudeConfig = config.claudeDevtools;
+  if (!claudeConfig) {
+    log("No config found, skipping Socket.IO setup");
+    return;
+  }
+  log("Initializing Socket.IO server");
+  initClaudeSession({
+    command: claudeConfig.claude.command,
+    args: claudeConfig.claude.args,
+    rootDir: claudeConfig.rootDir,
+    tunnelOrigin: claudeConfig.tunnelOrigin || null
+  });
+  const engine = new Engine();
+  const io = new Server();
+  io.bind(engine);
+  const session = getClaudeSessionInstance();
+  if (session) {
+    session.attachSocketIO(io);
+  }
+  nitroApp.router.use("/__claude_devtools_socket/", defineEventHandler({
+    handler(event) {
+      engine.handleRequest(event.node.req, event.node.res);
+      event._handled = true;
+    },
+    websocket: {
+      open(peer) {
+        engine.prepare(peer._internal.nodeReq);
+        engine.onWebSocket(
+          // @ts-expect-error - accessing internal
+          peer._internal.nodeReq,
+          // @ts-expect-error - accessing internal
+          peer._internal.nodeReq.socket,
+          peer.websocket
+        );
+      }
+    }
+  }));
+  log("Socket.IO server ready on /__claude_devtools_socket/");
+});

package/dist/runtime/server/skills-manager.d.ts

@@ -0,0 +1,36 @@
+export interface Skill {
+    name: string;
+    description: string;
+    content: string;
+    rawContent: string;
+    argumentHint?: string;
+    disableModelInvocation?: boolean;
+    userInvocable?: boolean;
+    allowedTools?: string[];
+    model?: string;
+    context?: 'fork';
+    agent?: string;
+    updatedAt: string;
+}
+export declare class SkillsManager {
+    private skillsDir;
+    constructor(projectPath: string);
+    private parseFrontmatter;
+    private buildFrontmatter;
+    getSkills(): Skill[];
+    getSkill(name: string): Skill | null;
+    getSkillNames(): string[];
+    saveSkill(skill: {
+        name: string;
+        description: string;
+        content: string;
+        argumentHint?: string;
+        disableModelInvocation?: boolean;
+        userInvocable?: boolean;
+        allowedTools?: string[];
+        model?: string;
+        context?: 'fork';
+        agent?: string;
+    }): Skill;
+    deleteSkill(name: string): boolean;
+}