mulmoclaude 0.1.0

package/src/plugins/manageSource/definition.ts

@@ -0,0 +1,63 @@
+import type { ToolDefinition } from "gui-chat-protocol";
+
+export const TOOL_NAME = "manageSource";
+
+const toolDefinition: ToolDefinition = {
+  type: "function",
+  name: TOOL_NAME,
+  description:
+    "Manage the user's information-source registry stored under <workspace>/sources/. Use this for RSS feeds, GitHub repos (releases or issues), and arXiv search queries. After every action the response carries the full registry so the UI can re-render. Always call action='list' to display the current registry in the canvas.",
+  parameters: {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["list", "register", "remove", "rebuild"],
+        description:
+          "What to do. 'list' = show the registry. 'register' = add a new source (requires title + url + fetcherKind, fetcherParams). 'remove' = delete by slug. 'rebuild' = run the daily aggregation pipeline now.",
+      },
+      slug: {
+        type: "string",
+        description:
+          "Source slug (lowercase letters/digits/hyphens). Required for action='remove'. Optional for action='register' (auto-derived from title when omitted).",
+      },
+      title: {
+        type: "string",
+        description: "Human-friendly source name. Required for action='register'.",
+      },
+      url: {
+        type: "string",
+        description:
+          "Canonical URL: feed URL for RSS, repo URL (https://github.com/<owner>/<name>) for github-*, or the arXiv search/listing URL for arxiv. Required for action='register'.",
+      },
+      fetcherKind: {
+        type: "string",
+        enum: ["rss", "github-releases", "github-issues", "arxiv"],
+        description:
+          "Which fetcher handles this source. Infer from the URL when registering: feed URLs → 'rss'; github.com/<owner>/<name> → 'github-releases' or 'github-issues' depending on user intent; arxiv.org → 'arxiv'.",
+      },
+      fetcherParams: {
+        type: "object",
+        description:
+          "Fetcher-specific params (flat object of string values). For 'rss' set { rss_url: '<feed URL>' }. For 'github-releases' / 'github-issues' set { github_repo: 'owner/name' }. For 'arxiv' set { arxiv_query: '<query, e.g. cat:cs.CL>' }.",
+      },
+      schedule: {
+        type: "string",
+        enum: ["daily", "weekly", "manual"],
+        description: "How often the pipeline should fetch this source. Default 'daily'.",
+      },
+      categories: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional category override. When omitted the auto-classifier picks from the 25-slug taxonomy.",
+      },
+      notes: {
+        type: "string",
+        description: "Free-form notes shown in the UI.",
+      },
+    },
+    required: ["action"],
+  },
+};
+
+export default toolDefinition;

package/src/plugins/manageSource/index.ts

@@ -0,0 +1,66 @@
+import type { ToolPlugin } from "../../tools/types";
+import type { ToolResult } from "gui-chat-protocol";
+import toolDefinition, { TOOL_NAME } from "./definition";
+import View from "./View.vue";
+import Preview from "./Preview.vue";
+import { apiPost } from "../../utils/api";
+import { API_ROUTES } from "../../config/apiRoutes";
+
+// Mirrors server/sources/types.ts#Source. Re-declared here so the
+// frontend doesn't have to import a server package.
+export interface Source {
+  slug: string;
+  title: string;
+  url: string;
+  fetcherKind: "rss" | "github-releases" | "github-issues" | "arxiv";
+  fetcherParams: Record<string, string>;
+  schedule: "daily" | "weekly" | "manual";
+  categories: string[];
+  maxItemsPerFetch: number;
+  addedAt: string;
+  notes?: string;
+}
+
+export interface RebuildSummary {
+  plannedCount: number;
+  itemCount: number;
+  duplicateCount: number;
+  archiveErrors: string[];
+  isoDate: string;
+}
+
+export interface ManageSourceData {
+  sources: Source[];
+  // Optional per-action context. Set on register to highlight the
+  // newly-added source; set on rebuild so the View can flash the
+  // run summary.
+  highlightSlug?: string;
+  lastRebuild?: RebuildSummary;
+  classifyRationale?: string;
+}
+
+const manageSourcePlugin: ToolPlugin<ManageSourceData> = {
+  toolDefinition,
+  async execute(_context, args) {
+    const result = await apiPost<ToolResult<ManageSourceData>>(API_ROUTES.sources.manage, args);
+    if (!result.ok) {
+      return {
+        toolName: TOOL_NAME,
+        uuid: crypto.randomUUID(),
+        message: result.error,
+      };
+    }
+    return {
+      ...result.data,
+      toolName: TOOL_NAME,
+      uuid: crypto.randomUUID(),
+    };
+  },
+  isEnabled: () => true,
+  generatingMessage: "Managing sources…",
+  viewComponent: View,
+  previewComponent: Preview,
+};
+
+export default manageSourcePlugin;
+export { TOOL_NAME };

package/src/plugins/markdown/Preview.vue

@@ -0,0 +1,77 @@
+<template>
+  <div class="p-3 bg-purple-100 rounded overflow-hidden">
+    <div class="text-sm text-gray-800 font-medium truncate">
+      {{ displayTitle }}
+    </div>
+    <div v-if="contentPreview" class="text-xs text-gray-500 mt-1 line-clamp-4 whitespace-pre-line">
+      {{ contentPreview }}
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import type { ToolResult } from "gui-chat-protocol";
+import { isFilePath, type MarkdownToolData } from "./definition";
+import { extractFirstH1 } from "../../utils/markdown/extractFirstH1";
+import { apiGet } from "../../utils/api";
+import { API_ROUTES } from "../../config/apiRoutes";
+
+const props = defineProps<{
+  result: ToolResult<MarkdownToolData>;
+}>();
+
+const fetchedContent = ref("");
+
+async function fetchContent(): Promise<void> {
+  const raw = props.result.data?.markdown;
+  if (!raw || !isFilePath(raw)) {
+    fetchedContent.value = "";
+    return;
+  }
+  const result = await apiGet<{ content?: string }>(API_ROUTES.files.content, {
+    path: raw,
+  });
+  if (!result.ok) {
+    fetchedContent.value = "";
+    return;
+  }
+  fetchedContent.value = result.data.content ?? "";
+}
+
+fetchContent();
+watch(() => props.result.data?.markdown, fetchContent);
+
+const displayTitle = computed(() => {
+  if (props.result.title) {
+    return props.result.title;
+  }
+  const markdown = resolvedMarkdown.value;
+  if (markdown) {
+    const heading = extractFirstH1(markdown);
+    if (heading) return heading;
+  }
+  return "Markdown Document";
+});
+
+const resolvedMarkdown = computed(() => {
+  const raw = props.result.data?.markdown;
+  if (!raw) return "";
+  return isFilePath(raw) ? fetchedContent.value : raw;
+});
+
+function extractPreview(markdown: string): string {
+  const lines = markdown
+    .split("\n")
+    .filter((line) => !/^#{1,6}\s/.test(line) && line.trim() !== "")
+    .map((line) => line.replace(/[*_`~[\]]/g, "").trim())
+    .filter(Boolean);
+  return lines.slice(0, 6).join("\n");
+}
+
+const contentPreview = computed(() => {
+  const markdown = resolvedMarkdown.value;
+  if (!markdown) return "";
+  return extractPreview(markdown);
+});
+</script>

package/src/plugins/markdown/View.vue

@@ -0,0 +1,476 @@
+<template>
+  <div class="markdown-container">
+    <div v-if="loading" class="min-h-full p-8 flex items-center justify-center">
+      <div class="text-gray-500">Loading document...</div>
+    </div>
+    <div v-else-if="loadError && !markdownContent" class="min-h-full p-8 flex items-center justify-center">
+      <div class="load-error-banner" role="alert">⚠ Failed to load document: {{ loadError }}</div>
+    </div>
+    <div v-else-if="!markdownContent" class="min-h-full p-8 flex items-center justify-center">
+      <div class="text-gray-500">No markdown content available</div>
+    </div>
+    <template v-else>
+      <div v-if="loadError" class="load-error-banner" role="alert">
+        ⚠ Failed to refresh document: {{ loadError }} — showing last successfully loaded content.
+      </div>
+      <div class="markdown-content-wrapper">
+        <div class="p-4">
+          <div class="header-row">
+            <h1 class="document-title">
+              {{ selectedResult.title || "Document" }}
+            </h1>
+            <div class="button-group">
+              <button class="download-btn download-btn-green" :disabled="pdfDownloading" @click="downloadPdf">
+                <span class="material-icons">{{ pdfDownloading ? "hourglass_empty" : "download" }}</span>
+                PDF
+              </button>
+            </div>
+            <span v-if="pdfError" class="text-xs text-red-500 self-center ml-2" :title="pdfError">⚠ PDF failed</span>
+          </div>
+          <div class="markdown-content prose prose-slate max-w-none" v-html="renderedHtml"></div>
+        </div>
+      </div>
+
+      <div class="bottom-bar-wrapper">
+        <details ref="sourceDetails" class="markdown-source" @toggle="onDetailsToggle">
+          <summary>Edit Markdown Source</summary>
+          <textarea v-model="editableMarkdown" class="markdown-editor" spellcheck="false"></textarea>
+          <div class="editor-actions">
+            <button class="apply-btn" :disabled="!hasChanges || saving" @click="applyMarkdown">
+              {{ saving ? "Saving..." : "Apply Changes" }}
+            </button>
+            <button class="cancel-btn" @click="cancelEdit">Cancel</button>
+          </div>
+          <p v-if="saveError" class="save-error" role="alert">⚠ {{ saveError }}</p>
+        </details>
+        <button v-show="!editing" class="copy-btn" :title="copied ? 'Copied!' : 'Copy'" @click="copyText">
+          <span class="material-icons">{{ copied ? "check" : "content_copy" }}</span>
+        </button>
+      </div>
+    </template>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed, ref, watch, nextTick } from "vue";
+import { marked } from "marked";
+import type { ToolResult } from "gui-chat-protocol";
+import { isFilePath, type MarkdownToolData } from "./definition";
+import { rewriteMarkdownImageRefs } from "../../utils/image/rewriteMarkdownImageRefs";
+import { usePdfDownload } from "../../composables/usePdfDownload";
+import { apiGet, apiPut } from "../../utils/api";
+import { API_ROUTES } from "../../config/apiRoutes";
+import { useClipboardCopy } from "../../composables/useClipboardCopy";
+import { toSafeFilename } from "../../utils/files/filename";
+
+const props = defineProps<{
+  selectedResult: ToolResult<MarkdownToolData>;
+}>();
+
+const emit = defineEmits<{
+  updateResult: [result: ToolResult<MarkdownToolData>];
+}>();
+
+const loading = ref(false);
+const saving = ref(false);
+// Human-readable message shown next to the Save button when a PUT
+// fails. null while the editor is idle or the last save succeeded.
+const saveError = ref<string | null>(null);
+// Error loading the markdown content from the server. Distinct from an
+// intentionally empty document — we used to wipe `markdownContent` on
+// failure, which made "fetch failed" look like "no content available".
+const loadError = ref<string | null>(null);
+// The actual markdown content (fetched from server or inline)
+const markdownContent = ref("");
+const editableMarkdown = ref("");
+
+async function fetchMarkdownContent(): Promise<void> {
+  loadError.value = null;
+  const raw = props.selectedResult.data?.markdown;
+  if (!raw) {
+    markdownContent.value = "";
+    editableMarkdown.value = "";
+    return;
+  }
+  if (isFilePath(raw)) {
+    loading.value = true;
+    const result = await apiGet<{ content?: string }>(API_ROUTES.files.content, {
+      path: raw,
+    });
+    if (!result.ok) {
+      // Preserve any previously-loaded content instead of wiping it —
+      // the user sees the banner AND whatever they were reading, not
+      // a blank canvas. editableMarkdown is left in sync so the editor
+      // (if open) doesn't flip between states.
+      loadError.value = result.error;
+      loading.value = false;
+      return;
+    }
+    markdownContent.value = result.data.content ?? "";
+    loading.value = false;
+  } else {
+    // Legacy inline content
+    markdownContent.value = raw;
+  }
+  editableMarkdown.value = markdownContent.value;
+}
+
+// Fetch on mount
+fetchMarkdownContent();
+
+const hasChanges = computed(() => {
+  return editableMarkdown.value !== markdownContent.value;
+});
+
+const renderedHtml = computed(() => {
+  if (!markdownContent.value) return "";
+  // Rewrite workspace-relative image refs BEFORE marked parses them —
+  // same approach as wiki/View.vue and FilesView.vue. Markdown files
+  // under `markdowns/<year>/foo.md` typically use `../images/x.png`,
+  // so the basePath is the directory of the file; for inline legacy
+  // content we have no path, so basePath is empty and only rooted
+  // references get rewritten.
+  const raw = props.selectedResult.data?.markdown;
+  const basePath = typeof raw === "string" && isFilePath(raw) ? raw.slice(0, raw.lastIndexOf("/")) : "";
+  const withImages = rewriteMarkdownImageRefs(markdownContent.value, basePath);
+  return marked(withImages) as string;
+});
+
+// Watch for scroll requests from viewState
+watch(
+  () => props.selectedResult?.viewState?.scrollToAnchor as string | undefined,
+  (anchorId) => {
+    if (!anchorId) return;
+    nextTick(() => {
+      const element = document.getElementById(anchorId);
+      if (element) {
+        element.scrollIntoView({ behavior: "smooth", block: "start" });
+      } else {
+        console.warn(`Anchor element with id "${anchorId}" not found`);
+      }
+    });
+  },
+);
+
+const sourceDetails = ref<HTMLDetailsElement>();
+const editing = ref(false);
+const { copied, copy } = useClipboardCopy();
+
+function onDetailsToggle(e: Event) {
+  const open = (e.target as HTMLDetailsElement).open;
+  editing.value = open;
+  if (!open) {
+    editableMarkdown.value = markdownContent.value;
+    saveError.value = null;
+  }
+}
+
+function cancelEdit() {
+  if (sourceDetails.value) sourceDetails.value.open = false;
+}
+
+async function copyText() {
+  await copy(markdownContent.value);
+}
+
+const { pdfDownloading, pdfError, downloadPdf: rawDownloadPdf } = usePdfDownload();
+
+async function downloadPdf() {
+  if (!markdownContent.value) return;
+  const prefix = props.selectedResult.data?.filenamePrefix;
+  const rawName = prefix || props.selectedResult.title || "document";
+  const title = toSafeFilename(rawName, "document");
+  await rawDownloadPdf(markdownContent.value, `${title}.pdf`);
+}
+
+async function applyMarkdown() {
+  const raw = props.selectedResult.data?.markdown;
+  if (!raw) return;
+
+  saveError.value = null;
+
+  // If file-based, save to server
+  if (isFilePath(raw)) {
+    saving.value = true;
+    const filename = raw.replace(/^(artifacts\/documents|markdowns)\//, "");
+    const result = await apiPut<unknown>(API_ROUTES.plugins.updateMarkdown.replace(":filename", filename), {
+      markdown: editableMarkdown.value,
+    });
+    saving.value = false;
+    if (!result.ok) {
+      saveError.value = `Save failed: ${result.error}`;
+      return;
+    }
+  }
+
+  // Update local state
+  markdownContent.value = editableMarkdown.value;
+
+  // Emit update to parent (clears pdfPath since content changed)
+  const updatedResult: ToolResult<MarkdownToolData> = {
+    ...props.selectedResult,
+    data: {
+      ...props.selectedResult.data,
+      markdown: isFilePath(raw) ? raw : editableMarkdown.value,
+      pdfPath: undefined,
+    },
+  };
+  emit("updateResult", updatedResult);
+
+  // Close the edit panel
+  if (sourceDetails.value) sourceDetails.value.open = false;
+}
+
+// Watch for external changes to selectedResult (when user clicks different result)
+watch(
+  () => props.selectedResult.data?.markdown,
+  () => {
+    fetchMarkdownContent();
+  },
+);
+</script>
+
+<style scoped>
+.markdown-container {
+  width: 100%;
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  background: white;
+}
+
+.markdown-content-wrapper {
+  flex: 1;
+  overflow-y: auto;
+  min-height: 0;
+}
+
+.header-row {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  margin-bottom: 1em;
+}
+
+.document-title {
+  font-size: 2em;
+  margin: 0;
+}
+
+.button-group {
+  display: flex;
+  gap: 0.5em;
+}
+
+.download-btn {
+  padding: 0.5em 1em;
+  color: white;
+  border: none;
+  border-radius: 4px;
+  cursor: pointer;
+  font-size: 0.9em;
+  display: flex;
+  align-items: center;
+  gap: 0.5em;
+}
+
+.download-btn-green {
+  background-color: #4caf50;
+}
+
+.download-btn .material-icons {
+  font-size: 1.2em;
+}
+
+.download-btn:disabled {
+  opacity: 0.6;
+  cursor: not-allowed;
+}
+
+.markdown-content :deep(h1) {
+  font-size: 2rem;
+  font-weight: bold;
+  margin-top: 1em;
+  margin-bottom: 0.5em;
+}
+
+.markdown-content :deep(h2) {
+  font-size: 1.75rem;
+  font-weight: bold;
+  margin-top: 1em;
+  margin-bottom: 0.5em;
+}
+
+.markdown-content :deep(h3) {
+  font-size: 1.5rem;
+  font-weight: bold;
+  margin-top: 1em;
+  margin-bottom: 0.5em;
+}
+
+.markdown-content :deep(h4) {
+  font-size: 1.25rem;
+  font-weight: bold;
+  margin-top: 1em;
+  margin-bottom: 0.5em;
+}
+
+.markdown-content :deep(h5) {
+  font-size: 1.125rem;
+  font-weight: bold;
+  margin-top: 1em;
+  margin-bottom: 0.5em;
+}
+
+.markdown-content :deep(h6) {
+  font-size: 1rem;
+  font-weight: bold;
+  margin-top: 1em;
+  margin-bottom: 0.5em;
+}
+
+.bottom-bar-wrapper {
+  position: relative;
+  flex-shrink: 0;
+}
+
+.copy-btn {
+  position: absolute;
+  bottom: 0.3rem;
+  right: 0.65rem;
+  padding: 0.4rem;
+  background: none;
+  border: none;
+  color: #333;
+  cursor: pointer;
+  z-index: 1;
+}
+
+.copy-btn:hover {
+  color: #000;
+}
+
+.copy-btn .material-icons {
+  font-size: 1.15rem;
+}
+
+.markdown-source {
+  padding: 0.5rem;
+  background: #f5f5f5;
+  border-top: 1px solid #e0e0e0;
+  font-family: monospace;
+  font-size: 0.85rem;
+  flex-shrink: 0;
+}
+
+.markdown-source summary {
+  cursor: pointer;
+  user-select: none;
+  padding: 0.5rem;
+  background: #e8e8e8;
+  border-radius: 4px;
+  font-weight: 500;
+  color: #333;
+}
+
+.markdown-source[open] summary {
+  margin-bottom: 0.5rem;
+}
+
+.markdown-source summary:hover {
+  background: #d8d8d8;
+}
+
+.markdown-editor {
+  width: 100%;
+  height: 40vh;
+  padding: 1rem;
+  background: #ffffff;
+  border: 1px solid #ccc;
+  border-radius: 4px;
+  color: #333;
+  font-family: "Courier New", monospace;
+  font-size: 0.9rem;
+  resize: vertical;
+  margin-bottom: 0.5rem;
+  line-height: 1.5;
+}
+
+.markdown-editor:focus {
+  outline: none;
+  border-color: #4caf50;
+  box-shadow: 0 0 0 2px rgba(76, 175, 80, 0.1);
+}
+
+.apply-btn {
+  padding: 0.5rem 1rem;
+  background: #4caf50;
+  color: white;
+  border: none;
+  border-radius: 4px;
+  cursor: pointer;
+  font-size: 0.9rem;
+  transition: background 0.2s;
+  font-weight: 500;
+}
+
+.apply-btn:hover {
+  background: #45a049;
+}
+
+.apply-btn:active {
+  background: #3d8b40;
+}
+
+.apply-btn:disabled {
+  background: #cccccc;
+  color: #666666;
+  cursor: not-allowed;
+  opacity: 0.6;
+}
+
+.apply-btn:disabled:hover {
+  background: #cccccc;
+}
+
+.editor-actions {
+  display: flex;
+  justify-content: space-between;
+}
+
+.save-error {
+  margin: 0.5rem 0 0;
+  padding: 0.4rem 0.6rem;
+  background: #fdecea;
+  color: #b71c1c;
+  border: 1px solid #f5c2c7;
+  border-radius: 4px;
+  font-size: 0.85rem;
+}
+
+.load-error-banner {
+  margin: 0.75rem 1rem;
+  padding: 0.5rem 0.75rem;
+  background: #fdecea;
+  color: #b71c1c;
+  border: 1px solid #f5c2c7;
+  border-radius: 4px;
+  font-size: 0.875rem;
+}
+
+.cancel-btn {
+  padding: 0.5rem 1rem;
+  background: #e0e0e0;
+  color: #333;
+  border: none;
+  border-radius: 4px;
+  cursor: pointer;
+  font-size: 0.9rem;
+  transition: background 0.2s;
+  font-weight: 500;
+}
+
+.cancel-btn:hover {
+  background: #d0d0d0;
+}
+</style>