openfox 0.2.4 → 1.0.1

package/dist/events-G6CKHDNZ.js

@@ -0,0 +1,114 @@
+import {
+  EventStore,
+  compactContext,
+  createEvent,
+  emitAssistantMessageStart,
+  emitChatDone,
+  emitChatError,
+  emitContextCompacted,
+  emitContextState,
+  emitCriteriaSet,
+  emitCriterionUpdated,
+  emitFileRead,
+  emitFormatRetry,
+  emitMessageDelta,
+  emitMessageDone,
+  emitMessageThinking,
+  emitModeChanged,
+  emitPhaseChanged,
+  emitRunningChanged,
+  emitSessionInitialized,
+  emitTodosUpdated,
+  emitToolCall,
+  emitToolOutput,
+  emitToolPreparing,
+  emitToolResult,
+  emitTurnSnapshot,
+  emitUserMessage,
+  getContextMessages,
+  getCurrentContextWindowId,
+  getCurrentWindowMessages,
+  getEventStore,
+  getReadFilesCache,
+  getRecentUserPromptsForSession,
+  getSessionState,
+  initEventStore,
+  isFileInCache,
+  isStoredEvent,
+  isTurnEvent
+} from "./chunk-BU2ZYOEA.js";
+import {
+  buildContextMessagesFromEventHistory,
+  buildContextMessagesFromMessages,
+  buildContextMessagesFromStoredEvents,
+  buildMessagesFromStoredEvents,
+  buildSnapshot,
+  buildSnapshotFromSessionState,
+  foldContextState,
+  foldCriteria,
+  foldIsRunning,
+  foldMode,
+  foldPhase,
+  foldSessionState,
+  foldTodos,
+  foldTurnEventsToSnapshotMessages,
+  getMessagesForWindow
+} from "./chunk-2KSCZSXQ.js";
+import "./chunk-3EHGGBWE.js";
+import "./chunk-TVQOONDR.js";
+import "./chunk-PNBH3RAX.js";
+export {
+  EventStore,
+  buildContextMessagesFromEventHistory,
+  buildContextMessagesFromMessages,
+  buildContextMessagesFromStoredEvents,
+  buildMessagesFromStoredEvents,
+  buildSnapshot,
+  buildSnapshotFromSessionState,
+  compactContext,
+  createEvent,
+  emitAssistantMessageStart,
+  emitChatDone,
+  emitChatError,
+  emitContextCompacted,
+  emitContextState,
+  emitCriteriaSet,
+  emitCriterionUpdated,
+  emitFileRead,
+  emitFormatRetry,
+  emitMessageDelta,
+  emitMessageDone,
+  emitMessageThinking,
+  emitModeChanged,
+  emitPhaseChanged,
+  emitRunningChanged,
+  emitSessionInitialized,
+  emitTodosUpdated,
+  emitToolCall,
+  emitToolOutput,
+  emitToolPreparing,
+  emitToolResult,
+  emitTurnSnapshot,
+  emitUserMessage,
+  foldContextState,
+  foldCriteria,
+  foldIsRunning,
+  foldMode,
+  foldPhase,
+  foldSessionState,
+  foldTodos,
+  foldTurnEventsToSnapshotMessages,
+  getContextMessages,
+  getCurrentContextWindowId,
+  getCurrentWindowMessages,
+  getEventStore,
+  getMessagesForWindow,
+  getReadFilesCache,
+  getRecentUserPromptsForSession,
+  getSessionState,
+  initEventStore,
+  isFileInCache,
+  isStoredEvent,
+  isTurnEvent
+};
+//# sourceMappingURL=events-G6CKHDNZ.js.map

package/dist/folding-O52L65VN.js

@@ -0,0 +1,37 @@
+import {
+  buildContextMessagesFromEventHistory,
+  buildContextMessagesFromMessages,
+  buildContextMessagesFromStoredEvents,
+  buildMessagesFromStoredEvents,
+  buildSnapshot,
+  buildSnapshotFromSessionState,
+  foldContextState,
+  foldCriteria,
+  foldIsRunning,
+  foldMode,
+  foldPendingConfirmations,
+  foldPhase,
+  foldSessionState,
+  foldTodos,
+  foldTurnEventsToSnapshotMessages,
+  getMessagesForWindow
+} from "./chunk-2KSCZSXQ.js";
+export {
+  buildContextMessagesFromEventHistory,
+  buildContextMessagesFromMessages,
+  buildContextMessagesFromStoredEvents,
+  buildMessagesFromStoredEvents,
+  buildSnapshot,
+  buildSnapshotFromSessionState,
+  foldContextState,
+  foldCriteria,
+  foldIsRunning,
+  foldMode,
+  foldPendingConfirmations,
+  foldPhase,
+  foldSessionState,
+  foldTodos,
+  foldTurnEventsToSnapshotMessages,
+  getMessagesForWindow
+};
+//# sourceMappingURL=folding-O52L65VN.js.map

package/dist/{init-2EJ5AC7Z.js → init-MKTUIGZU.js}

@@ -1,14 +1,15 @@
 import {
   addProvider,
   saveGlobalConfig
-} from "./chunk-GZ7ZVJIW.js";
+} from "./chunk-3UQACISJ.js";
 import {
   detectBackend,
   detectModel
-} from "./chunk-5ZUU23XF.js";
-import "./chunk-26NRL3HX.js";
-import "./chunk-U62ZECSQ.js";
-import "./chunk-AF7XS4OI.js";
+} from "./chunk-U6BUT37A.js";
+import "./chunk-XFXOSPYH.js";
+import "./chunk-5YQAXUKO.js";
+import "./chunk-M2C5GEQR.js";
+import "./chunk-PNBH3RAX.js";
 
 // src/cli/init.ts
 import { select, text, spinner, outro, confirm } from "@clack/prompts";
@@ -21,11 +22,14 @@ var LLM_OPTIONS = [
 function createBaseConfig() {
   return {
     providers: [],
+    defaultModelSelection: void 0,
     activeProviderId: void 0,
+    activeWorkflowId: void 0,
     server: { port: 10369, host: "127.0.0.1", openBrowser: true },
     logging: { level: "info" },
     database: { path: "" },
-    workspace: { workdir: process.cwd() }
+    workspace: { workdir: process.cwd() },
+    visionFallback: { enabled: false, url: "http://localhost:11434", model: "qwen3-vl:2b", timeout: 120 }
   };
 }
 async function promptNetworkAccessibility() {
@@ -95,7 +99,7 @@ async function runInitWithSelect(mode, existingConfig) {
         name: "Default",
         url: found.url,
         backend: found.backend,
-        maxContext: 2e5,
+        models: [],
         isActive: true
       });
     } else {
@@ -129,10 +133,10 @@ async function runInitWithSelect(mode, existingConfig) {
           name: "Default",
           url,
           backend,
-          maxContext: 2e5,
+          models: [],
           isActive: true
         });
-        const { setDefaultModelSelection } = await import("./config-GIXXE4VK.js");
+        const { setDefaultModelSelection } = await import("./config-GIFCEJDU.js");
         config = setDefaultModelSelection(config, config.providers[config.providers.length - 1].id, model ?? "auto");
       } catch {
         s2.stop("Server isn't available");
@@ -153,10 +157,10 @@ async function runInitWithSelect(mode, existingConfig) {
           name: "Default",
           url,
           backend: "auto",
-          maxContext: 2e5,
+          models: [],
           isActive: true
         });
-        const { setDefaultModelSelection } = await import("./config-GIXXE4VK.js");
+        const { setDefaultModelSelection } = await import("./config-GIFCEJDU.js");
         config = setDefaultModelSelection(config, config.providers[config.providers.length - 1].id, "auto");
       }
     }
@@ -172,8 +176,37 @@ async function runInitWithSelect(mode, existingConfig) {
     }
   });
   config.workspace = { workdir: String(workdirChoice).replace(/\/$/, "") };
+  const visionChoice = await confirm({
+    message: "Configure vision fallback for non-vision models?",
+    initialValue: false
+  });
+  if (visionChoice === true) {
+    const visionUrl = await text({
+      message: "Vision fallback server URL",
+      placeholder: "http://localhost:11434",
+      initialValue: config.visionFallback?.url || "http://localhost:11434",
+      validate: (value) => {
+        if (!value || value.length === 0) return "URL is required";
+        if (!value.startsWith("http")) return "Must start with http://";
+      }
+    });
+    const visionModel = await text({
+      message: "Vision fallback model name",
+      placeholder: "qwen3-vl:2b",
+      initialValue: config.visionFallback?.model || "qwen3-vl:2b",
+      validate: (value) => {
+        if (!value || value.length === 0) return "Model name is required";
+      }
+    });
+    config.visionFallback = {
+      enabled: true,
+      url: String(visionUrl),
+      model: String(visionModel),
+      timeout: 120
+    };
+  }
   if (config.providers.length > 0 && !config.defaultModelSelection) {
-    const { setDefaultModelSelection } = await import("./config-GIXXE4VK.js");
+    const { setDefaultModelSelection } = await import("./config-GIFCEJDU.js");
     config = setDefaultModelSelection(config, config.providers[0].id, "auto");
   }
   await saveGlobalConfig(mode, config);
@@ -182,4 +215,4 @@ async function runInitWithSelect(mode, existingConfig) {
 export {
   runInitWithSelect
 };
-//# sourceMappingURL=init-2EJ5AC7Z.js.map
+//# sourceMappingURL=init-MKTUIGZU.js.map

package/dist/orchestrator-4CBESUGB.js

@@ -0,0 +1,39 @@
+import {
+  filterToolRegistryForStepDone,
+  runBuilderTurn,
+  runChatTurn,
+  runVerifierTurn
+} from "./chunk-OWDPT3M6.js";
+import {
+  TurnMetrics,
+  createChatDoneEvent,
+  createMessageDoneEvent,
+  createMessageStartEvent,
+  createToolCallEvent,
+  createToolResultEvent
+} from "./chunk-ARKA56ZM.js";
+import "./chunk-BU2ZYOEA.js";
+import "./chunk-2KSCZSXQ.js";
+import "./chunk-S4QKTRGJ.js";
+import "./chunk-22CTURMH.js";
+import "./chunk-7IOZFJBW.js";
+import "./chunk-XKFPU2FA.js";
+import "./chunk-3EHGGBWE.js";
+import "./chunk-TPT6HP4H.js";
+import "./chunk-TVQOONDR.js";
+import "./chunk-XFXOSPYH.js";
+import "./chunk-5YQAXUKO.js";
+import "./chunk-PNBH3RAX.js";
+export {
+  TurnMetrics,
+  createChatDoneEvent,
+  createMessageDoneEvent,
+  createMessageStartEvent,
+  createToolCallEvent,
+  createToolResultEvent,
+  filterToolRegistryForStepDone,
+  runBuilderTurn,
+  runChatTurn,
+  runVerifierTurn
+};
+//# sourceMappingURL=orchestrator-4CBESUGB.js.map

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openfox",
-  "version": "0.2.4",
+  "version": "1.0.1",
   "description": "Local-LLM-first agentic coding assistant",
   "type": "module",
   "bin": {
@@ -34,6 +34,9 @@
     "test": "vitest run --reporter=dot --silent=passed-only && vitest run --reporter=dot --silent=passed-only --config e2e/vitest.config.ts",
     "test:unit": "vitest run --reporter=dot --silent=passed-only",
     "test:e2e": "vitest run --reporter=dot --silent=passed-only --config e2e/vitest.config.ts",
+    "test:playwright": "playwright test --config=e2e-playwright/playwright.config.ts",
+    "test:playwright:ui": "playwright test --config=e2e-playwright/playwright.config.ts --ui",
+    "test:playwright:headed": "playwright test --config=e2e-playwright/playwright.config.ts --headed",
     "test:cov": "vitest run --reporter=dot --silent=passed-only --coverage && vitest run --reporter=dot --silent=passed-only --config e2e/vitest.config.ts --coverage",
     "test:cov:unit": "vitest run --reporter=dot --silent=passed-only --coverage",
     "test:cov:e2e": "vitest run --reporter=dot --silent=passed-only --config e2e/vitest.config.ts --coverage",
@@ -59,12 +62,12 @@
     "gray-matter": "^4.0.3",
     "html2canvas": "^1.4.1",
     "ignore": "^7.0.5",
+    "node-pty": "^1.1.0",
     "open": "^11.0.0",
     "openai": "^6.33.0",
     "pyright": "^1.1.408",
     "react-markdown": "^10.1.0",
     "react-syntax-highlighter": "^16.1.1",
-    "react-virtuoso": "4.18.3",
     "remark-gfm": "^4.0.1",
     "sql-language-server": "^1.7.1",
     "turndown": "^7.2.2",
@@ -82,6 +85,10 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
+    "@playwright/test": "^1.58.2",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.19.15",
     "@types/react": "^19.0.8",

package/dist/{paths-4BPXWB2W.js → paths-MM76AWYB.js}

@@ -5,7 +5,7 @@ import {
   getGlobalConfigPath,
   getGlobalDataDir,
   getSkillsDir
-} from "./chunk-AF7XS4OI.js";
+} from "./chunk-5YQAXUKO.js";
 export {
   ensureDataDirExists,
   getDatabasePath,
@@ -14,4 +14,4 @@ export {
   getGlobalDataDir,
   getSkillsDir
 };
-//# sourceMappingURL=paths-4BPXWB2W.js.map
+//# sourceMappingURL=paths-MM76AWYB.js.map

package/dist/processor-LAKHPIG3.js

@@ -0,0 +1,236 @@
+import {
+  generateSessionName,
+  needsNameGeneration
+} from "./chunk-QDEKU5RL.js";
+import {
+  getEventStore,
+  updateSessionMetadata
+} from "./chunk-BU2ZYOEA.js";
+import {
+  buildMessagesFromStoredEvents,
+  foldPendingConfirmations
+} from "./chunk-2KSCZSXQ.js";
+import {
+  createChatMessageMessage,
+  createContextStateMessage,
+  createSessionRunningMessage,
+  createSessionStateMessage
+} from "./chunk-S4QKTRGJ.js";
+import "./chunk-3EHGGBWE.js";
+import "./chunk-TPT6HP4H.js";
+import "./chunk-TVQOONDR.js";
+import {
+  logger
+} from "./chunk-PNBH3RAX.js";
+
+// src/server/queue/processor.ts
+var QueueProcessor = class {
+  deps;
+  unsubscribe = null;
+  activeAgents = /* @__PURE__ */ new Map();
+  constructor(deps) {
+    this.deps = deps;
+  }
+  start() {
+    if (this.unsubscribe) {
+      logger.warn("QueueProcessor already started");
+      return;
+    }
+    this.unsubscribe = this.deps.sessionManager.subscribe((event) => {
+      if (event.type === "queue_added") {
+        this.handleQueueAdded(event.sessionId);
+      } else if (event.type === "running_changed" && !event.isRunning) {
+        this.handleTurnDone(event.sessionId);
+      }
+    });
+    logger.debug("QueueProcessor started");
+  }
+  stop() {
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = null;
+    }
+    for (const controller of this.activeAgents.values()) {
+      controller.abort();
+    }
+    this.activeAgents.clear();
+    logger.debug("QueueProcessor stopped");
+  }
+  abortSession(sessionId) {
+    const controller = this.activeAgents.get(sessionId);
+    if (controller) {
+      controller.abort();
+      this.activeAgents.delete(sessionId);
+      return true;
+    }
+    return false;
+  }
+  handleQueueAdded(sessionId) {
+    const { sessionManager } = this.deps;
+    const session = sessionManager.getSession(sessionId);
+    if (!session) return;
+    if (session.isRunning) {
+      logger.debug("Session is running, not starting new turn", { sessionId });
+      return;
+    }
+    if (!sessionManager.hasQueuedMessages(sessionId)) {
+      logger.debug("No queued messages", { sessionId });
+      return;
+    }
+    this.startTurn(sessionId);
+  }
+  handleTurnDone(sessionId) {
+    logger.debug("Turn done, checking for more queued messages", { sessionId });
+    const { sessionManager } = this.deps;
+    if (!sessionManager.hasQueuedMessages(sessionId)) {
+      logger.debug("No more queued messages", { sessionId });
+      return;
+    }
+    this.startTurn(sessionId);
+  }
+  startTurn(sessionId) {
+    const { sessionManager, broadcastForSession } = this.deps;
+    logger.info("Starting turn from queue processor", { sessionId });
+    const session = sessionManager.getSession(sessionId);
+    if (!session || session.isRunning) {
+      logger.warn("Cannot start turn: session not found or already running", { sessionId });
+      return;
+    }
+    const queue = sessionManager.getQueueState(sessionId);
+    if (queue.length === 0) {
+      logger.warn("Cannot start turn: queue is empty", { sessionId });
+      return;
+    }
+    const controller = new AbortController();
+    this.activeAgents.set(sessionId, controller);
+    sessionManager.setRunning(sessionId, true);
+    broadcastForSession(sessionId, createSessionRunningMessage(true));
+    const nextAsap = queue.find((m) => m.mode === "asap") ?? queue[0];
+    if (nextAsap) {
+      sessionManager.cancelQueuedMessage(sessionId, nextAsap.queueId);
+      const userMessage = sessionManager.addMessage(sessionId, {
+        role: "user",
+        content: nextAsap.content,
+        ...nextAsap.attachments ? { attachments: nextAsap.attachments } : {}
+      });
+      broadcastForSession(sessionId, createChatMessageMessage(userMessage));
+      logger.debug("Added queued message to session", { sessionId, queueId: nextAsap.queueId, messageId: userMessage.id });
+      const messageCount = this.getSessionMessageCount(sessionId);
+      const currentSession = sessionManager.getSession(sessionId);
+      logger.debug("Session name generation check (queue)", {
+        sessionId,
+        title: currentSession?.metadata.title,
+        messageCount,
+        needsGeneration: currentSession ? needsNameGeneration(currentSession.metadata.title, messageCount) : false
+      });
+      if (currentSession && needsNameGeneration(currentSession.metadata.title, messageCount)) {
+        const eventStore = getEventStore();
+        generateSessionName({
+          userMessage: nextAsap.content,
+          llmClient: this.deps.getLLMClient(),
+          signal: controller.signal
+        }).then((result) => {
+          logger.debug("Session name generation result (queue)", {
+            sessionId,
+            success: result.success,
+            name: result.name,
+            error: result.error
+          });
+          if (result.success && result.name) {
+            updateSessionMetadata(sessionId, { title: result.name });
+            eventStore.append(sessionId, {
+              type: "session.name_generated",
+              data: { name: result.name }
+            });
+            const updatedSession = sessionManager.getSession(sessionId);
+            if (updatedSession) {
+              const events = eventStore.getEvents(sessionId);
+              const messages = buildMessagesFromStoredEvents(events);
+              const pendingConfirmations = foldPendingConfirmations(events);
+              broadcastForSession(sessionId, createSessionStateMessage(updatedSession, messages, pendingConfirmations));
+            }
+          }
+        }).catch((error) => {
+          logger.error("Session name generation failed (queue)", {
+            sessionId,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        });
+      }
+    }
+    this.runTurn(sessionId, controller);
+  }
+  async runTurn(sessionId, controller) {
+    const { sessionManager, getLLMClient, getActiveProvider, broadcastForSession, providerManager } = this.deps;
+    const session = sessionManager.getSession(sessionId);
+    if (session?.providerId && session.providerModel) {
+      const currentActiveProviderId = providerManager.getActiveProviderId();
+      const currentModel = providerManager.getCurrentModel();
+      if (currentActiveProviderId !== session.providerId || currentModel !== session.providerModel) {
+        logger.info("Switching to session provider", {
+          sessionId,
+          fromProvider: currentActiveProviderId,
+          fromModel: currentModel,
+          toProvider: session.providerId,
+          toModel: session.providerModel
+        });
+        const result = await providerManager.activateProvider(session.providerId, { model: session.providerModel });
+        if (!result.success) {
+          logger.error("Failed to activate session provider", { sessionId, error: result.error });
+        }
+      }
+    }
+    const llmClient = getLLMClient();
+    const provider = getActiveProvider?.();
+    const statsIdentity = {
+      providerId: provider?.id ?? `provider:${llmClient.getModel()}`,
+      providerName: provider?.name ?? "Unknown Provider",
+      backend: provider?.backend ?? llmClient.getBackend(),
+      model: llmClient.getModel()
+    };
+    const { runChatTurn } = await import("./orchestrator-4CBESUGB.js");
+    runChatTurn({
+      sessionManager,
+      sessionId,
+      llmClient,
+      statsIdentity,
+      signal: controller.signal,
+      onMessage: (msg) => broadcastForSession(sessionId, msg)
+    }).catch((error) => {
+      if (error instanceof Error && error.message === "Aborted") {
+        return;
+      }
+      logger.error("QueueProcessor turn error", { sessionId, error });
+    }).finally(() => {
+      this.activeAgents.delete(sessionId);
+      const session2 = this.deps.sessionManager.getSession(sessionId);
+      if (!session2) return;
+      const hasMore = sessionManager.hasQueuedMessages(sessionId);
+      if (!hasMore) {
+        sessionManager.setRunning(sessionId, false);
+        const contextState = sessionManager.getContextState(sessionId);
+        broadcastForSession(sessionId, createContextStateMessage(contextState));
+        return;
+      }
+      this.startTurn(sessionId);
+    });
+  }
+  getSessionMessageCount(sessionId) {
+    const eventStore = getEventStore();
+    const events = eventStore.getEvents(sessionId);
+    let count = 0;
+    for (const event of events) {
+      if (event.type === "message.start") {
+        const data = event.data;
+        if (data.role === "user") {
+          count++;
+        }
+      }
+    }
+    return count;
+  }
+};
+export {
+  QueueProcessor
+};
+//# sourceMappingURL=processor-LAKHPIG3.js.map

package/dist/{project-creator-CWPKRIKI.js → project-creator-KAQXMZCT.js}

@@ -1,8 +1,8 @@
 import {
   createProject
-} from "./chunk-N2XYX4ZA.js";
-import "./chunk-4Z2OZ6NX.js";
-import "./chunk-U62ZECSQ.js";
+} from "./chunk-XKFPU2FA.js";
+import "./chunk-3EHGGBWE.js";
+import "./chunk-PNBH3RAX.js";
 
 // src/server/utils/project-creator.ts
 import { mkdir } from "fs/promises";
@@ -12,11 +12,11 @@ function validateProjectName(name) {
   if (!name || name.trim() === "") {
     return { valid: false, error: "Project name cannot be empty" };
   }
-  const validPattern = /^[a-zA-Z0-9._-]+$/;
+  const validPattern = /^[a-zA-Z0-9._ -]+$/;
   if (!validPattern.test(name)) {
     return {
       valid: false,
-      error: "Project name can only contain letters, numbers, hyphens, underscores, and dots"
+      error: "Project name can only contain letters, numbers, hyphens, underscores, dots, and spaces"
     };
   }
   if (name.includes("/") || name.includes("\\") || name.includes("..")) {
@@ -39,7 +39,8 @@ async function createDirectoryWithGit(projectName, workdir) {
   if (!validation.valid) {
     throw new Error(validation.error);
   }
-  const fullPath = join(workdir, projectName);
+  const sanitizedName = projectName.trim().replace(/\s+/g, "-");
+  const fullPath = join(workdir, sanitizedName);
   const exists = await directoryExists(fullPath);
   if (exists) {
     throw new Error(`Directory already exists: ${fullPath}. Please choose a different name or use the existing directory from Browse Projects.`);
@@ -58,7 +59,7 @@ async function createDirectoryWithGit(projectName, workdir) {
     const errorMessage = error instanceof Error ? error.message : "Unknown error";
     throw new Error(`Failed to initialize git repository: ${errorMessage}`);
   }
-  const project = createProject(projectName, fullPath);
+  const project = createProject(projectName, workdir);
   return project;
 }
 export {
@@ -66,4 +67,4 @@ export {
   directoryExists,
   validateProjectName
 };
-//# sourceMappingURL=project-creator-CWPKRIKI.js.map
+//# sourceMappingURL=project-creator-KAQXMZCT.js.map

package/dist/projects-GSMMEVSO.js

@@ -0,0 +1,19 @@
+import {
+  createProject,
+  deleteProject,
+  getProject,
+  getProjectByWorkdir,
+  listProjects,
+  updateProject
+} from "./chunk-XKFPU2FA.js";
+import "./chunk-3EHGGBWE.js";
+import "./chunk-PNBH3RAX.js";
+export {
+  createProject,
+  deleteProject,
+  getProject,
+  getProjectByWorkdir,
+  listProjects,
+  updateProject
+};
+//# sourceMappingURL=projects-GSMMEVSO.js.map