gyrus 0.1.0

package/src/operations/adr.ts

@@ -0,0 +1,312 @@
+/**
+ * ADR Operations
+ * Shared business logic for ADRs used by both CLI and MCP interfaces
+ */
+
+import type { WorkspaceManager } from "../services/workspace.ts";
+import type { AdrStatus, AdrType } from "../types/index.ts";
+import type {
+  OperationResult,
+  AdrListInput,
+  AdrListResult,
+  AdrReadInput,
+  AdrReadResult,
+  AdrSearchInput,
+  AdrSearchResult,
+  AdrCreateInput,
+  AdrCreateResult,
+  AdrUpdateInput,
+  AdrUpdateResult,
+} from "./types.ts";
+
+/**
+ * List ADRs with optional filtering
+ */
+export async function listAdrs(
+  manager: WorkspaceManager,
+  input: AdrListInput,
+): Promise<OperationResult<AdrListResult>> {
+  // Get service for specified workspace or active workspace
+  const workspaceName = input.workspace ?? manager.getActiveWorkspaceName();
+  const service = manager.getAdrService(workspaceName);
+
+  if (!service) {
+    if (input.workspace) {
+      const ws = manager.getWorkspace(input.workspace);
+      if (!ws) {
+        return {
+          success: false,
+          error: `Workspace "${input.workspace}" not found. Use 'gyrus list' to see available workspaces.`,
+        };
+      }
+      return {
+        success: false,
+        error: `ADRs folder not found in workspace "${input.workspace}". Make sure the workspace has an 'adrs' directory.`,
+      };
+    }
+    return {
+      success: false,
+      error:
+        "ADRs folder not found in the active workspace. Make sure the workspace has an 'adrs' directory.",
+    };
+  }
+
+  const adrs = await service.listAdrs({
+    status: input.status as AdrStatus | undefined,
+    type: input.type as AdrType | undefined,
+    tags: input.tags,
+  });
+
+  // Group by status
+  const byStatus: Record<string, typeof adrs> = {};
+  for (const adr of adrs) {
+    const status = adr.status;
+    if (!byStatus[status]) byStatus[status] = [];
+    byStatus[status].push(adr);
+  }
+
+  return {
+    success: true,
+    data: {
+      workspace: workspaceName,
+      adrs,
+      byStatus,
+    },
+  };
+}
+
+/**
+ * Read a specific ADR by name
+ */
+export async function readAdr(
+  manager: WorkspaceManager,
+  input: AdrReadInput,
+): Promise<OperationResult<AdrReadResult>> {
+  // Get service for specified workspace or active workspace
+  const workspaceName = input.workspace ?? manager.getActiveWorkspaceName();
+  const service = manager.getAdrService(workspaceName);
+
+  if (!service) {
+    if (input.workspace) {
+      const ws = manager.getWorkspace(input.workspace);
+      if (!ws) {
+        return {
+          success: false,
+          error: `Workspace "${input.workspace}" not found. Use 'gyrus list' to see available workspaces.`,
+        };
+      }
+      return {
+        success: false,
+        error: `ADRs folder not found in workspace "${input.workspace}". Make sure the workspace has an 'adrs' directory.`,
+      };
+    }
+    return {
+      success: false,
+      error:
+        "ADRs folder not found in the active workspace. Make sure the workspace has an 'adrs' directory.",
+    };
+  }
+
+  const adr = await service.findAdr(input.name);
+
+  if (!adr) {
+    return {
+      success: false,
+      error: `ADR not found in workspace "${workspaceName}": "${input.name}"\n\nTip: You can use a partial name to search. Try using part of the title or date.`,
+    };
+  }
+
+  return {
+    success: true,
+    data: {
+      workspace: workspaceName,
+      adr,
+    },
+  };
+}
+
+/**
+ * Search ADRs
+ */
+export async function searchAdrs(
+  manager: WorkspaceManager,
+  input: AdrSearchInput,
+): Promise<OperationResult<AdrSearchResult>> {
+  // Validate input
+  if (!input.query && !input.status && !input.type && !input.tags?.length) {
+    return {
+      success: false,
+      error:
+        "At least one search parameter (query, status, type, or tags) must be provided.",
+    };
+  }
+
+  // Get service for specified workspace or active workspace
+  const workspaceName = input.workspace ?? manager.getActiveWorkspaceName();
+  const service = manager.getAdrService(workspaceName);
+
+  if (!service) {
+    if (input.workspace) {
+      const ws = manager.getWorkspace(input.workspace);
+      if (!ws) {
+        return {
+          success: false,
+          error: `Workspace "${input.workspace}" not found. Use 'gyrus list' to see available workspaces.`,
+        };
+      }
+      return {
+        success: false,
+        error: `ADRs folder not found in workspace "${input.workspace}". Make sure the workspace has an 'adrs' directory.`,
+      };
+    }
+    return {
+      success: false,
+      error:
+        "ADRs folder not found in the active workspace. Make sure the workspace has an 'adrs' directory.",
+    };
+  }
+
+  const adrs = await service.searchAdrs({
+    query: input.query,
+    status: input.status as AdrStatus | undefined,
+    type: input.type as AdrType | undefined,
+    tags: input.tags,
+  });
+
+  return {
+    success: true,
+    data: {
+      workspace: workspaceName,
+      query: input.query,
+      adrs,
+    },
+  };
+}
+
+/**
+ * Create a new ADR
+ */
+export async function createAdr(
+  manager: WorkspaceManager,
+  input: AdrCreateInput,
+): Promise<OperationResult<AdrCreateResult>> {
+  // Get service for specified workspace or active workspace
+  const workspaceName = input.workspace ?? manager.getActiveWorkspaceName();
+  const service = manager.getAdrService(workspaceName);
+
+  if (!service) {
+    if (input.workspace) {
+      const ws = manager.getWorkspace(input.workspace);
+      if (!ws) {
+        return {
+          success: false,
+          error: `Workspace "${input.workspace}" not found. Use 'gyrus list' to see available workspaces.`,
+        };
+      }
+      return {
+        success: false,
+        error: `ADRs folder not found in workspace "${input.workspace}". Make sure the workspace has an 'adrs' directory.`,
+      };
+    }
+    return {
+      success: false,
+      error:
+        "ADRs folder not found in the active workspace. Make sure the workspace has an 'adrs' directory.",
+    };
+  }
+
+  const result = await service.createAdr({
+    title: input.title,
+    type: input.type as AdrType,
+    workingFolder: input.workingFolder,
+    description: input.description,
+    tags: input.tags,
+    status: input.status as AdrStatus | undefined,
+    content: input.content,
+  });
+
+  if (!result.success || !result.adr) {
+    return {
+      success: false,
+      error: result.message,
+    };
+  }
+
+  return {
+    success: true,
+    data: {
+      workspace: workspaceName,
+      adr: result.adr,
+    },
+  };
+}
+
+/**
+ * Update an existing ADR
+ */
+export async function updateAdr(
+  manager: WorkspaceManager,
+  input: AdrUpdateInput,
+): Promise<OperationResult<AdrUpdateResult>> {
+  // Get service for specified workspace or active workspace
+  const workspaceName = input.workspace ?? manager.getActiveWorkspaceName();
+  const service = manager.getAdrService(workspaceName);
+
+  if (!service) {
+    if (input.workspace) {
+      const ws = manager.getWorkspace(input.workspace);
+      if (!ws) {
+        return {
+          success: false,
+          error: `Workspace "${input.workspace}" not found. Use 'gyrus list' to see available workspaces.`,
+        };
+      }
+      return {
+        success: false,
+        error: `ADRs folder not found in workspace "${input.workspace}". Make sure the workspace has an 'adrs' directory.`,
+      };
+    }
+    return {
+      success: false,
+      error:
+        "ADRs folder not found in the active workspace. Make sure the workspace has an 'adrs' directory.",
+    };
+  }
+
+  // Track which fields are being updated
+  const updatedFields: string[] = [];
+  if (input.title !== undefined) updatedFields.push("title");
+  if (input.description !== undefined) updatedFields.push("description");
+  if (input.status !== undefined) updatedFields.push("status");
+  if (input.type !== undefined) updatedFields.push("type");
+  if (input.tags !== undefined) updatedFields.push("tags");
+  if (input.content !== undefined) updatedFields.push("content");
+  if (input.workingFolder !== undefined) updatedFields.push("workingFolder");
+
+  const result = await service.updateAdr({
+    name: input.name,
+    title: input.title,
+    description: input.description,
+    status: input.status as AdrStatus | undefined,
+    type: input.type as AdrType | undefined,
+    tags: input.tags,
+    content: input.content,
+    workingFolder: input.workingFolder,
+  });
+
+  if (!result.success || !result.adr) {
+    return {
+      success: false,
+      error: result.message,
+    };
+  }
+
+  return {
+    success: true,
+    data: {
+      workspace: workspaceName,
+      adr: result.adr,
+      updatedFields,
+    },
+  };
+}

package/src/operations/index.ts

@@ -0,0 +1,58 @@
+/**
+ * Operations Index
+ * Exports all shared operations for use by CLI and MCP interfaces
+ */
+
+// Types
+export type {
+  OperationResult,
+  KnowledgeListInput,
+  KnowledgeListResult,
+  KnowledgeReadInput,
+  KnowledgeReadResult,
+  KnowledgeSearchInput,
+  KnowledgeSearchResult,
+  KnowledgeCreateInput,
+  KnowledgeCreateResult,
+  KnowledgeUpdateInput,
+  KnowledgeUpdateResult,
+  AdrListInput,
+  AdrListResult,
+  AdrReadInput,
+  AdrReadResult,
+  AdrSearchInput,
+  AdrSearchResult,
+  AdrCreateInput,
+  AdrCreateResult,
+  AdrUpdateInput,
+  AdrUpdateResult,
+  WorkspaceInfo,
+  WorkspaceListResult,
+  WorkspaceSwitchInput,
+  WorkspaceSwitchResult,
+} from "./types.ts";
+
+// Knowledge operations
+export {
+  listKnowledge,
+  readKnowledge,
+  searchKnowledge,
+  createKnowledge,
+  updateKnowledge,
+} from "./knowledge.ts";
+
+// ADR operations
+export {
+  listAdrs,
+  readAdr,
+  searchAdrs,
+  createAdr,
+  updateAdr,
+} from "./adr.ts";
+
+// Workspace operations
+export {
+  listWorkspaces,
+  switchWorkspace,
+  getWorkspaceInfo,
+} from "./workspace.ts";

package/src/operations/knowledge.ts

@@ -0,0 +1,324 @@
+/**
+ * Knowledge Operations
+ * Shared business logic for knowledge notes used by both CLI and MCP interfaces
+ */
+
+import type { WorkspaceManager } from "../services/workspace.ts";
+import type { KnowledgeCategory } from "../types/index.ts";
+import type {
+  OperationResult,
+  KnowledgeListInput,
+  KnowledgeListResult,
+  KnowledgeReadInput,
+  KnowledgeReadResult,
+  KnowledgeSearchInput,
+  KnowledgeSearchResult,
+  KnowledgeCreateInput,
+  KnowledgeCreateResult,
+  KnowledgeUpdateInput,
+  KnowledgeUpdateResult,
+} from "./types.ts";
+
+/**
+ * List knowledge notes with optional filtering
+ */
+export async function listKnowledge(
+  manager: WorkspaceManager,
+  input: KnowledgeListInput,
+): Promise<OperationResult<KnowledgeListResult>> {
+  // Get service for specified workspace or active workspace
+  const workspaceName = input.workspace ?? manager.getActiveWorkspaceName();
+  const service = manager.getKnowledgeService(workspaceName);
+
+  if (!service) {
+    if (input.workspace) {
+      const ws = manager.getWorkspace(input.workspace);
+      if (!ws) {
+        return {
+          success: false,
+          error: `Workspace "${input.workspace}" not found. Use 'gyrus list' to see available workspaces.`,
+        };
+      }
+      return {
+        success: false,
+        error: `Knowledge folder not found in workspace "${input.workspace}". Make sure the workspace has a 'knowledge' directory.`,
+      };
+    }
+    return {
+      success: false,
+      error:
+        "Knowledge folder not found in the active workspace. Make sure the workspace has a 'knowledge' directory.",
+    };
+  }
+
+  const notes = await service.listNotes({
+    category: input.category as KnowledgeCategory | undefined,
+    tags: input.tags,
+  });
+
+  // Group by category
+  const byCategory: Record<string, typeof notes> = {};
+  for (const note of notes) {
+    const cat = note.category;
+    if (!byCategory[cat]) byCategory[cat] = [];
+    byCategory[cat].push(note);
+  }
+
+  return {
+    success: true,
+    data: {
+      workspace: workspaceName,
+      notes,
+      byCategory,
+    },
+  };
+}
+
+/**
+ * Read a specific knowledge note by ID or path
+ */
+export async function readKnowledge(
+  manager: WorkspaceManager,
+  input: KnowledgeReadInput,
+): Promise<OperationResult<KnowledgeReadResult>> {
+  // Validate input
+  if (!input.id && !input.path) {
+    return {
+      success: false,
+      error: "At least one of 'id' or 'path' must be provided.",
+    };
+  }
+
+  // Get service for specified workspace or active workspace
+  const workspaceName = input.workspace ?? manager.getActiveWorkspaceName();
+  const service = manager.getKnowledgeService(workspaceName);
+
+  if (!service) {
+    if (input.workspace) {
+      const ws = manager.getWorkspace(input.workspace);
+      if (!ws) {
+        return {
+          success: false,
+          error: `Workspace "${input.workspace}" not found. Use 'gyrus list' to see available workspaces.`,
+        };
+      }
+      return {
+        success: false,
+        error: `Knowledge folder not found in workspace "${input.workspace}". Make sure the workspace has a 'knowledge' directory.`,
+      };
+    }
+    return {
+      success: false,
+      error:
+        "Knowledge folder not found in the active workspace. Make sure the workspace has a 'knowledge' directory.",
+    };
+  }
+
+  // Try to find the note
+  let note = null;
+
+  if (input.id) {
+    note = await service.getNote(input.id);
+  }
+
+  if (!note && input.path) {
+    note = await service.getNoteByPath(input.path);
+  }
+
+  if (!note) {
+    const identifier = input.id ?? input.path;
+    return {
+      success: false,
+      error: `Note not found in workspace "${workspaceName}": "${identifier}"`,
+    };
+  }
+
+  return {
+    success: true,
+    data: {
+      workspace: workspaceName,
+      note,
+    },
+  };
+}
+
+/**
+ * Search knowledge notes
+ */
+export async function searchKnowledge(
+  manager: WorkspaceManager,
+  input: KnowledgeSearchInput,
+): Promise<OperationResult<KnowledgeSearchResult>> {
+  // Validate input
+  if (!input.query && !input.tags?.length && !input.category) {
+    return {
+      success: false,
+      error:
+        "At least one search parameter (query, tags, or category) must be provided.",
+    };
+  }
+
+  // Get service for specified workspace or active workspace
+  const workspaceName = input.workspace ?? manager.getActiveWorkspaceName();
+  const service = manager.getKnowledgeService(workspaceName);
+
+  if (!service) {
+    if (input.workspace) {
+      const ws = manager.getWorkspace(input.workspace);
+      if (!ws) {
+        return {
+          success: false,
+          error: `Workspace "${input.workspace}" not found. Use 'gyrus list' to see available workspaces.`,
+        };
+      }
+      return {
+        success: false,
+        error: `Knowledge folder not found in workspace "${input.workspace}". Make sure the workspace has a 'knowledge' directory.`,
+      };
+    }
+    return {
+      success: false,
+      error:
+        "Knowledge folder not found in the active workspace. Make sure the workspace has a 'knowledge' directory.",
+    };
+  }
+
+  const notes = await service.searchNotes({
+    query: input.query,
+    tags: input.tags,
+    category: input.category as KnowledgeCategory | undefined,
+  });
+
+  return {
+    success: true,
+    data: {
+      workspace: workspaceName,
+      query: input.query,
+      notes,
+    },
+  };
+}
+
+/**
+ * Create a new knowledge note
+ */
+export async function createKnowledge(
+  manager: WorkspaceManager,
+  input: KnowledgeCreateInput,
+): Promise<OperationResult<KnowledgeCreateResult>> {
+  // Get service for specified workspace or active workspace
+  const workspaceName = input.workspace ?? manager.getActiveWorkspaceName();
+  const service = manager.getKnowledgeService(workspaceName);
+
+  if (!service) {
+    if (input.workspace) {
+      const ws = manager.getWorkspace(input.workspace);
+      if (!ws) {
+        return {
+          success: false,
+          error: `Workspace "${input.workspace}" not found. Use 'gyrus list' to see available workspaces.`,
+        };
+      }
+      return {
+        success: false,
+        error: `Knowledge folder not found in workspace "${input.workspace}". Make sure the workspace has a 'knowledge' directory.`,
+      };
+    }
+    return {
+      success: false,
+      error:
+        "Knowledge folder not found in the active workspace. Make sure the workspace has a 'knowledge' directory.",
+    };
+  }
+
+  const result = await service.createNote({
+    id: input.id,
+    title: input.title,
+    category: input.category,
+    content: input.content,
+    tags: input.tags,
+    related: input.related,
+    description: input.description,
+  });
+
+  if (!result.success || !result.note) {
+    return {
+      success: false,
+      error: result.message,
+    };
+  }
+
+  return {
+    success: true,
+    data: {
+      workspace: workspaceName,
+      note: result.note,
+    },
+  };
+}
+
+/**
+ * Update an existing knowledge note
+ */
+export async function updateKnowledge(
+  manager: WorkspaceManager,
+  input: KnowledgeUpdateInput,
+): Promise<OperationResult<KnowledgeUpdateResult>> {
+  // Get service for specified workspace or active workspace
+  const workspaceName = input.workspace ?? manager.getActiveWorkspaceName();
+  const service = manager.getKnowledgeService(workspaceName);
+
+  if (!service) {
+    if (input.workspace) {
+      const ws = manager.getWorkspace(input.workspace);
+      if (!ws) {
+        return {
+          success: false,
+          error: `Workspace "${input.workspace}" not found. Use 'gyrus list' to see available workspaces.`,
+        };
+      }
+      return {
+        success: false,
+        error: `Knowledge folder not found in workspace "${input.workspace}". Make sure the workspace has a 'knowledge' directory.`,
+      };
+    }
+    return {
+      success: false,
+      error:
+        "Knowledge folder not found in the active workspace. Make sure the workspace has a 'knowledge' directory.",
+    };
+  }
+
+  // Track which fields are being updated
+  const updatedFields: string[] = [];
+  if (input.title !== undefined) updatedFields.push("title");
+  if (input.content !== undefined) updatedFields.push("content");
+  if (input.tags !== undefined) updatedFields.push("tags");
+  if (input.related !== undefined) updatedFields.push("related");
+  if (input.description !== undefined) updatedFields.push("description");
+
+  const result = await service.updateNote({
+    id: input.id,
+    title: input.title,
+    content: input.content,
+    tags: input.tags,
+    related: input.related,
+    description: input.description,
+  });
+
+  if (!result.success || !result.note) {
+    return {
+      success: false,
+      error: result.message,
+    };
+  }
+
+  return {
+    success: true,
+    data: {
+      workspace: workspaceName,
+      note: result.note,
+      updatedFields,
+    },
+  };
+}