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

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/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;
+}

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

@@ -0,0 +1,210 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createLogger } from "../logger.js";
+const log = createLogger("skills", { timestamp: true });
+export class SkillsManager {
+  skillsDir;
+  constructor(projectPath) {
+    this.skillsDir = join(projectPath, ".claude", "skills");
+    if (!existsSync(this.skillsDir)) {
+      mkdirSync(this.skillsDir, { recursive: true });
+      log("Created skills directory", { path: this.skillsDir });
+    }
+  }
+  // Parse YAML frontmatter from markdown content
+  parseFrontmatter(content) {
+    const frontmatterRegex = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (!match) {
+      return { frontmatter: {}, body: content.trim() };
+    }
+    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();
+      switch (key) {
+        case "name":
+          frontmatter.name = value;
+          break;
+        case "description":
+          frontmatter.description = value;
+          break;
+        case "argument-hint":
+          frontmatter["argument-hint"] = value;
+          break;
+        case "disable-model-invocation":
+          frontmatter["disable-model-invocation"] = value === "true";
+          break;
+        case "user-invocable":
+          frontmatter["user-invocable"] = value === "true";
+          break;
+        case "allowed-tools":
+          frontmatter["allowed-tools"] = value;
+          break;
+        case "model":
+          frontmatter.model = value;
+          break;
+        case "context":
+          frontmatter.context = value;
+          break;
+        case "agent":
+          frontmatter.agent = value;
+          break;
+      }
+    }
+    return { frontmatter, body: body.trim() };
+  }
+  // Build frontmatter string
+  buildFrontmatter(skill) {
+    const lines = ["---"];
+    if (skill.name) {
+      lines.push(`name: ${skill.name}`);
+    }
+    if (skill.description) {
+      lines.push(`description: ${skill.description}`);
+    }
+    if (skill.argumentHint) {
+      lines.push(`argument-hint: ${skill.argumentHint}`);
+    }
+    if (skill.disableModelInvocation !== void 0) {
+      lines.push(`disable-model-invocation: ${skill.disableModelInvocation}`);
+    }
+    if (skill.userInvocable !== void 0) {
+      lines.push(`user-invocable: ${skill.userInvocable}`);
+    }
+    if (skill.allowedTools && skill.allowedTools.length > 0) {
+      lines.push(`allowed-tools: ${skill.allowedTools.join(", ")}`);
+    }
+    if (skill.model) {
+      lines.push(`model: ${skill.model}`);
+    }
+    if (skill.context) {
+      lines.push(`context: ${skill.context}`);
+    }
+    if (skill.agent) {
+      lines.push(`agent: ${skill.agent}`);
+    }
+    lines.push("---");
+    return lines.join("\n");
+  }
+  // Get all skills
+  getSkills() {
+    const skills = [];
+    if (!existsSync(this.skillsDir)) return skills;
+    const entries = readdirSync(this.skillsDir);
+    for (const entry of entries) {
+      const skillDir = join(this.skillsDir, entry);
+      const stat = statSync(skillDir);
+      if (!stat.isDirectory()) continue;
+      const skillFile = join(skillDir, "SKILL.md");
+      if (!existsSync(skillFile)) continue;
+      const fileStat = statSync(skillFile);
+      const rawContent = readFileSync(skillFile, "utf-8");
+      const { frontmatter, body } = this.parseFrontmatter(rawContent);
+      skills.push({
+        name: frontmatter.name || entry,
+        description: frontmatter.description || "",
+        content: body,
+        rawContent,
+        argumentHint: frontmatter["argument-hint"],
+        disableModelInvocation: frontmatter["disable-model-invocation"],
+        userInvocable: frontmatter["user-invocable"],
+        allowedTools: frontmatter["allowed-tools"] ? frontmatter["allowed-tools"].split(",").map((s) => s.trim()) : void 0,
+        model: frontmatter.model,
+        context: frontmatter.context === "fork" ? "fork" : void 0,
+        agent: frontmatter.agent,
+        updatedAt: fileStat.mtime.toISOString()
+      });
+    }
+    return skills.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  // Get single skill
+  getSkill(name) {
+    const skillDir = join(this.skillsDir, name);
+    const skillFile = join(skillDir, "SKILL.md");
+    if (!existsSync(skillFile)) return null;
+    const stat = statSync(skillFile);
+    const rawContent = readFileSync(skillFile, "utf-8");
+    const { frontmatter, body } = this.parseFrontmatter(rawContent);
+    return {
+      name: frontmatter.name || name,
+      description: frontmatter.description || "",
+      content: body,
+      rawContent,
+      argumentHint: frontmatter["argument-hint"],
+      disableModelInvocation: frontmatter["disable-model-invocation"],
+      userInvocable: frontmatter["user-invocable"],
+      allowedTools: frontmatter["allowed-tools"] ? frontmatter["allowed-tools"].split(",").map((s) => s.trim()) : void 0,
+      model: frontmatter.model,
+      context: frontmatter.context === "fork" ? "fork" : void 0,
+      agent: frontmatter.agent,
+      updatedAt: stat.mtime.toISOString()
+    };
+  }
+  // Get skill names only (for agent skills selector)
+  getSkillNames() {
+    if (!existsSync(this.skillsDir)) return [];
+    const names = [];
+    const entries = readdirSync(this.skillsDir);
+    for (const entry of entries) {
+      const skillDir = join(this.skillsDir, entry);
+      const stat = statSync(skillDir);
+      if (!stat.isDirectory()) continue;
+      const skillFile = join(skillDir, "SKILL.md");
+      if (existsSync(skillFile)) {
+        names.push(entry);
+      }
+    }
+    return names.sort();
+  }
+  // Create or update skill
+  saveSkill(skill) {
+    const safeName = skill.name.replace(/[^\w-]/g, "-").toLowerCase();
+    const skillDir = join(this.skillsDir, safeName);
+    const skillFile = join(skillDir, "SKILL.md");
+    if (!existsSync(skillDir)) {
+      mkdirSync(skillDir, { recursive: true });
+    }
+    const frontmatter = this.buildFrontmatter({
+      name: safeName,
+      description: skill.description,
+      argumentHint: skill.argumentHint,
+      disableModelInvocation: skill.disableModelInvocation,
+      userInvocable: skill.userInvocable,
+      allowedTools: skill.allowedTools,
+      model: skill.model,
+      context: skill.context,
+      agent: skill.agent
+    });
+    const rawContent = `${frontmatter}
+
+${skill.content}`;
+    writeFileSync(skillFile, rawContent, "utf-8");
+    log("Saved skill", { name: safeName, path: skillFile });
+    return {
+      name: safeName,
+      description: skill.description,
+      content: skill.content,
+      rawContent,
+      argumentHint: skill.argumentHint,
+      disableModelInvocation: skill.disableModelInvocation,
+      userInvocable: skill.userInvocable,
+      allowedTools: skill.allowedTools,
+      model: skill.model,
+      context: skill.context,
+      agent: skill.agent,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  // Delete skill
+  deleteSkill(name) {
+    const skillDir = join(this.skillsDir, name);
+    if (!existsSync(skillDir)) return false;
+    rmSync(skillDir, { recursive: true });
+    log("Deleted skill", { name });
+    return true;
+  }
+}