tgo-wiki 0.1.0

package/packages/server/src/tools/document-tools.ts

@@ -0,0 +1,46 @@
+import { assertCanUseTool, DocumentService, toWikiError } from "../../../core/src/index.js";
+import type { ServerContext } from "../context.js";
+import { toolError, toolSuccess } from "./response.js";
+
+type ToolHandlerResult = {
+  content: { type: "text"; text: string }[];
+  structuredContent: Record<string, unknown>;
+  isError?: boolean;
+};
+
+export async function callDocumentUpload(
+  ctx: ServerContext,
+  input: { session_id: string; file_name: string; mime_type: string; content_base64: string }
+): Promise<ToolHandlerResult> {
+  try {
+    assertCanUseTool(ctx.role, "document_upload");
+    const result = await new DocumentService(ctx.workspaceRoot).upload({
+      sessionId: input.session_id,
+      fileName: input.file_name,
+      mimeType: input.mime_type,
+      contentBase64: input.content_base64,
+      createdBy: ctx.agentId
+    });
+    return result.ok ? toolSuccess({ ...result.value }) : toolError(result.error);
+  } catch (error) {
+    return toolError(toWikiError(error, "validation_failed"));
+  }
+}
+
+export async function callDocumentParse(
+  ctx: ServerContext,
+  input: { session_id: string; document_id: string; parser?: "auto" | string; reparse?: boolean }
+): Promise<ToolHandlerResult> {
+  try {
+    assertCanUseTool(ctx.role, "document_parse");
+    const result = await new DocumentService(ctx.workspaceRoot).parse({
+      sessionId: input.session_id,
+      documentId: input.document_id,
+      parser: input.parser,
+      reparse: input.reparse
+    });
+    return result.ok ? toolSuccess({ ...result.value }) : toolError(result.error);
+  } catch (error) {
+    return toolError(toWikiError(error, "validation_failed"));
+  }
+}

package/packages/server/src/tools/publish-tools.ts

@@ -0,0 +1,33 @@
+import * as z from "zod/v4";
+import { assertCanUseTool, PublishService, toWikiError } from "../../../core/src/index.js";
+import type { ServerContext } from "../context.js";
+import { toolError, toolSuccess } from "./response.js";
+
+type ToolHandlerResult = {
+  content: { type: "text"; text: string }[];
+  structuredContent: Record<string, unknown>;
+  isError?: boolean;
+};
+
+export const wikiPublishSessionSchema = z.object({
+  session_id: z.string().regex(/^[a-zA-Z0-9._-]+$/),
+  channel: z.literal("stable").optional(),
+  mode: z.literal("ff-only").optional()
+});
+
+export async function callWikiPublishSession(
+  ctx: ServerContext,
+  input: { session_id: string; channel?: "stable"; mode?: "ff-only" }
+): Promise<ToolHandlerResult> {
+  try {
+    assertCanUseTool(ctx.role, "wiki_publish_session");
+    const result = await new PublishService(ctx.workspaceRoot).publish({
+      sessionId: input.session_id,
+      channel: input.channel,
+      mode: input.mode
+    });
+    return result.ok ? toolSuccess({ ...result.value }) : toolError(result.error);
+  } catch (error) {
+    return toolError(toWikiError(error, "git_error"));
+  }
+}

package/packages/server/src/tools/read-tools.ts

@@ -0,0 +1,52 @@
+import { assertCanUseTool, toWikiError, VfsService, WikiService } from "../../../core/src/index.js";
+import type { ServerContext } from "../context.js";
+import { toolError, toolSuccess } from "./response.js";
+
+type ToolHandlerResult = {
+  content: { type: "text"; text: string }[];
+  structuredContent: Record<string, unknown>;
+  isError?: boolean;
+};
+
+export async function callVfsExec(
+  ctx: ServerContext,
+  input: { command: string; ref?: string }
+): Promise<ToolHandlerResult> {
+  try {
+    assertCanUseTool(ctx.role, "vfs_exec");
+    const result = await new VfsService(ctx.workspaceRoot).exec(input);
+    return result.ok ? toolSuccess({ ...result.value }) : toolError(result.error);
+  } catch (error) {
+    return toolError(toWikiError(error, "git_error"));
+  }
+}
+
+export async function callWikiRead(
+  ctx: ServerContext,
+  input: { path: string; ref?: string; include_frontmatter?: boolean }
+): Promise<ToolHandlerResult> {
+  try {
+    assertCanUseTool(ctx.role, "wiki_read");
+    const result = await new WikiService(ctx.workspaceRoot).read({
+      path: input.path,
+      ref: input.ref,
+      includeFrontmatter: input.include_frontmatter
+    });
+    return result.ok ? toolSuccess({ ...result.value }) : toolError(result.error);
+  } catch (error) {
+    return toolError(toWikiError(error, "git_error"));
+  }
+}
+
+export async function callWikiChannelStatus(
+  ctx: ServerContext,
+  input: { channel?: "stable" | string }
+): Promise<ToolHandlerResult> {
+  try {
+    assertCanUseTool(ctx.role, "wiki_channel_status");
+    const result = await new WikiService(ctx.workspaceRoot).channelStatus(input);
+    return result.ok ? toolSuccess({ ...result.value }) : toolError(result.error);
+  } catch (error) {
+    return toolError(toWikiError(error, "git_error"));
+  }
+}

package/packages/server/src/tools/response.ts

@@ -0,0 +1,24 @@
+import type { WikiError } from "../../../core/src/index.js";
+
+export function toolSuccess<T extends Record<string, unknown>>(value: T) {
+  return {
+    content: [{ type: "text" as const, text: JSON.stringify(value, null, 2) }],
+    structuredContent: value
+  };
+}
+
+export function toolError(error: WikiError) {
+  const value = {
+    error: {
+      code: error.code,
+      message: error.message,
+      details: error.details
+    }
+  };
+
+  return {
+    content: [{ type: "text" as const, text: JSON.stringify(value, null, 2) }],
+    structuredContent: value,
+    isError: true
+  };
+}

package/packages/server/src/tools/session-tools.ts

@@ -0,0 +1,100 @@
+import { assertCanUseTool, SessionWorkflowService, toWikiError } from "../../../core/src/index.js";
+import type { ServerContext } from "../context.js";
+import { toolError, toolSuccess } from "./response.js";
+
+type ToolHandlerResult = {
+  content: { type: "text"; text: string }[];
+  structuredContent: Record<string, unknown>;
+  isError?: boolean;
+};
+
+export async function callWikiSessionStart(
+  ctx: ServerContext,
+  input: { base_ref?: string; purpose?: string; agent_id?: string }
+): Promise<ToolHandlerResult> {
+  try {
+    assertCanUseTool(ctx.role, "wiki_session_start");
+    const result = await new SessionWorkflowService(ctx.workspaceRoot).start({
+      baseRef: input.base_ref,
+      purpose: input.purpose,
+      agentId: input.agent_id ?? ctx.agentId
+    });
+    return result.ok
+      ? toolSuccess({
+          session_id: result.value.sessionId,
+          branch: result.value.branch,
+          worktree: result.value.worktree,
+          base_ref: result.value.baseRef,
+          base_commit: result.value.baseCommit
+        })
+      : toolError(result.error);
+  } catch (error) {
+    return toolError(toWikiError(error, "git_error"));
+  }
+}
+
+export async function callWikiSessionPatch(
+  ctx: ServerContext,
+  input: { session_id: string; path: string; content: string; reason?: string }
+): Promise<ToolHandlerResult> {
+  try {
+    assertCanUseTool(ctx.role, "wiki_session_patch");
+    const result = await new SessionWorkflowService(ctx.workspaceRoot).patch({
+      sessionId: input.session_id,
+      path: input.path,
+      content: input.content,
+      reason: input.reason
+    });
+    return result.ok ? toolSuccess({ ...result.value }) : toolError(result.error);
+  } catch (error) {
+    return toolError(toWikiError(error, "git_error"));
+  }
+}
+
+export async function callWikiSessionValidate(
+  ctx: ServerContext,
+  input: { session_id: string; paths?: string[] }
+): Promise<ToolHandlerResult> {
+  try {
+    assertCanUseTool(ctx.role, "wiki_session_validate");
+    const result = await new SessionWorkflowService(ctx.workspaceRoot).validate({
+      sessionId: input.session_id,
+      paths: input.paths
+    });
+    return result.ok ? toolSuccess({ ...result.value }) : toolError(result.error);
+  } catch (error) {
+    return toolError(toWikiError(error, "git_error"));
+  }
+}
+
+export async function callWikiSessionDiff(
+  ctx: ServerContext,
+  input: { session_id: string; paths?: string[] }
+): Promise<ToolHandlerResult> {
+  try {
+    assertCanUseTool(ctx.role, "wiki_session_diff");
+    const result = await new SessionWorkflowService(ctx.workspaceRoot).diff({
+      sessionId: input.session_id,
+      paths: input.paths
+    });
+    return result.ok ? toolSuccess({ ...result.value }) : toolError(result.error);
+  } catch (error) {
+    return toolError(toWikiError(error, "git_error"));
+  }
+}
+
+export async function callWikiSessionCommit(
+  ctx: ServerContext,
+  input: { session_id: string; message: string }
+): Promise<ToolHandlerResult> {
+  try {
+    assertCanUseTool(ctx.role, "wiki_session_commit");
+    const result = await new SessionWorkflowService(ctx.workspaceRoot).commit({
+      sessionId: input.session_id,
+      message: input.message
+    });
+    return result.ok ? toolSuccess({ ...result.value }) : toolError(result.error);
+  } catch (error) {
+    return toolError(toWikiError(error, "git_error"));
+  }
+}

package/packages/server/src/tools/source-tools.ts

@@ -0,0 +1,32 @@
+import { assertCanUseTool, SourceService, toWikiError } from "../../../core/src/index.js";
+import type { ServerContext } from "../context.js";
+import { toolError, toolSuccess } from "./response.js";
+
+type ToolHandlerResult = {
+  content: { type: "text"; text: string }[];
+  structuredContent: Record<string, unknown>;
+  isError?: boolean;
+};
+
+export async function callSourceList(ctx: ServerContext, input: { ref?: string } = {}): Promise<ToolHandlerResult> {
+  try {
+    assertCanUseTool(ctx.role, "source_list");
+    const result = await new SourceService(ctx.workspaceRoot).list(input);
+    return result.ok ? toolSuccess({ ...result.value }) : toolError(result.error);
+  } catch (error) {
+    return toolError(toWikiError(error, "document_not_found"));
+  }
+}
+
+export async function callSourceRead(
+  ctx: ServerContext,
+  input: { document_id: string; ref?: string }
+): Promise<ToolHandlerResult> {
+  try {
+    assertCanUseTool(ctx.role, "source_read");
+    const result = await new SourceService(ctx.workspaceRoot).read(input);
+    return result.ok ? toolSuccess({ ...result.value }) : toolError(result.error);
+  } catch (error) {
+    return toolError(toWikiError(error, "document_not_found"));
+  }
+}

package/packages/server/src/tools/web-tools.ts

@@ -0,0 +1,26 @@
+import { assertCanUseTool, toWikiError, WebIngestionService } from "../../../core/src/index.js";
+import type { ServerContext } from "../context.js";
+import { toolError, toolSuccess } from "./response.js";
+
+type ToolHandlerResult = {
+  content: { type: "text"; text: string }[];
+  structuredContent: Record<string, unknown>;
+  isError?: boolean;
+};
+
+export async function callWebFetch(
+  ctx: ServerContext,
+  input: { session_id: string; url: string }
+): Promise<ToolHandlerResult> {
+  try {
+    assertCanUseTool(ctx.role, "web_fetch");
+    const result = await new WebIngestionService(ctx.workspaceRoot).fetch({
+      sessionId: input.session_id,
+      url: input.url,
+      createdBy: ctx.agentId
+    });
+    return result.ok ? toolSuccess({ ...result.value }) : toolError(result.error);
+  } catch (error) {
+    return toolError(toWikiError(error, "validation_failed"));
+  }
+}