@azerate/claudette-mcp 1.0.0 → 1.2.0

package/dist/scripts.d.ts

@@ -0,0 +1,29 @@
+export interface ScriptInfo {
+    name: string;
+    command: string;
+    status: 'running' | 'stopped' | 'error';
+    startedAt?: string;
+    exitCode?: number;
+}
+export interface ScriptStatus {
+    found: boolean;
+    script?: {
+        id: string;
+        name: string;
+        status: string;
+        output: string[];
+    };
+}
+export declare function getScripts(workspacePath: string): Promise<{
+    scripts: ScriptInfo[];
+    hasPackageJson: boolean;
+}>;
+export declare function getScriptOutput(workspacePath: string, scriptName: string): Promise<string | null>;
+export declare function startScript(workspacePath: string, scriptName: string): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+export declare function stopScript(workspacePath: string, scriptName: string): Promise<{
+    success: boolean;
+    error?: string;
+}>;

package/dist/scripts.js

@@ -0,0 +1,61 @@
+// Script management functions for Claudette MCP server
+import { stripAnsi } from './utils.js';
+// Claudette server API base URL
+const CLAUDETTE_API = "http://localhost:52001";
+// Get list of scripts from workspace
+export async function getScripts(workspacePath) {
+    try {
+        const response = await fetch(`${CLAUDETTE_API}/api/scripts?path=${encodeURIComponent(workspacePath)}`);
+        if (!response.ok)
+            return { scripts: [], hasPackageJson: false };
+        return await response.json();
+    }
+    catch {
+        return { scripts: [], hasPackageJson: false };
+    }
+}
+// Get script output
+export async function getScriptOutput(workspacePath, scriptName) {
+    try {
+        const response = await fetch(`${CLAUDETTE_API}/api/scripts/status?path=${encodeURIComponent(workspacePath)}&scriptName=${encodeURIComponent(scriptName)}`);
+        if (!response.ok)
+            return null;
+        const data = await response.json();
+        if (!data.found || !data.script)
+            return null;
+        // Join output lines and strip ANSI codes
+        const output = data.script.output.join('');
+        return stripAnsi(output);
+    }
+    catch {
+        return null;
+    }
+}
+// Start a script
+export async function startScript(workspacePath, scriptName) {
+    try {
+        const response = await fetch(`${CLAUDETTE_API}/api/scripts/run`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ path: workspacePath, scriptName, autoLaunchBrowser: true }),
+        });
+        return await response.json();
+    }
+    catch (err) {
+        return { success: false, error: err.message };
+    }
+}
+// Stop a script
+export async function stopScript(workspacePath, scriptName) {
+    try {
+        const response = await fetch(`${CLAUDETTE_API}/api/scripts/stop`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ path: workspacePath, scriptName }),
+        });
+        return await response.json();
+    }
+    catch (err) {
+        return { success: false, error: err.message };
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1 @@
+export declare function stripAnsi(str: string): string;

package/dist/utils.js

@@ -0,0 +1,12 @@
+// Utility functions for Claudette MCP server
+// Strip ANSI escape codes from a string
+export function stripAnsi(str) {
+    return str
+        .replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '')
+        .replace(/\x1b\][^\x07]*\x07/g, '')
+        .replace(/\x1b[()][AB012]/g, '')
+        .replace(/\x1b[>=]/g, '')
+        .replace(/\x07/g, '')
+        .replace(/\r/g, '')
+        .replace(/\x1b\[\?[0-9;]*[a-zA-Z]/g, '');
+}

package/dist/workspace.d.ts

@@ -0,0 +1,12 @@
+export interface WorkspaceConfig {
+    name: string;
+    path: string;
+    configured: boolean;
+    memory: string[];
+}
+export declare function getWorkspaceConfigPath(workspacePath: string): string;
+export declare function getWorkspaceConfig(workspacePath: string): WorkspaceConfig | null;
+export declare function saveWorkspaceConfig(config: WorkspaceConfig): void;
+export declare function clearMemory(workspacePath: string): boolean;
+export declare function deleteMemoryNotes(workspacePath: string, indices: number[]): number;
+export declare function replaceMemory(workspacePath: string, notes: string[]): boolean;

package/dist/workspace.js

@@ -0,0 +1,74 @@
+// Workspace configuration functions for Claudette MCP server
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+// Claudette data directory
+const DATA_DIR = join(homedir(), '.claudette');
+const WORKSPACE_CONFIGS_DIR = join(DATA_DIR, 'workspace-configs');
+// Get workspace config path
+export function getWorkspaceConfigPath(workspacePath) {
+    const safeName = workspacePath.replace(/[\\/:*?"<>|]/g, '-').replace(/--+/g, '-');
+    return join(WORKSPACE_CONFIGS_DIR, `${safeName}.json`);
+}
+// Read workspace config
+export function getWorkspaceConfig(workspacePath) {
+    const configPath = getWorkspaceConfigPath(workspacePath);
+    if (!existsSync(configPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(configPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+// Save workspace config
+export function saveWorkspaceConfig(config) {
+    if (!existsSync(WORKSPACE_CONFIGS_DIR)) {
+        mkdirSync(WORKSPACE_CONFIGS_DIR, { recursive: true });
+    }
+    const configPath = getWorkspaceConfigPath(config.path);
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+// Clear all memory notes
+export function clearMemory(workspacePath) {
+    const config = getWorkspaceConfig(workspacePath);
+    if (!config)
+        return false;
+    config.memory = [];
+    saveWorkspaceConfig(config);
+    return true;
+}
+// Delete specific memory notes by indices (0-based)
+export function deleteMemoryNotes(workspacePath, indices) {
+    const config = getWorkspaceConfig(workspacePath);
+    if (!config || !config.memory)
+        return 0;
+    // Sort indices in descending order to delete from end first
+    const sortedIndices = [...indices].sort((a, b) => b - a);
+    let deleted = 0;
+    for (const idx of sortedIndices) {
+        if (idx >= 0 && idx < config.memory.length) {
+            config.memory.splice(idx, 1);
+            deleted++;
+        }
+    }
+    saveWorkspaceConfig(config);
+    return deleted;
+}
+// Replace all memory with new notes (for summarization)
+export function replaceMemory(workspacePath, notes) {
+    let config = getWorkspaceConfig(workspacePath);
+    if (!config) {
+        config = {
+            name: workspacePath.split(/[/\\]/).pop() || "workspace",
+            path: workspacePath,
+            configured: false,
+            memory: [],
+        };
+    }
+    const timestamp = new Date().toLocaleString();
+    config.memory = notes.map(note => `[${timestamp}] ${note}`);
+    saveWorkspaceConfig(config);
+    return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azerate/claudette-mcp",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "MCP server for Claudette IDE - TypeScript errors, git changes, checkpoints, memory, and script management",
   "type": "module",
   "main": "dist/index.js",