pi-para 0.6.7 → 0.7.1

package/src/tools/edit-read.ts

@@ -0,0 +1,193 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { QMDStore } from "qmd-engine";
+import { formatFreshness } from "../query.js";
+import { autoLinkSlugs, syncFrontmatterLinks } from "../link-utils.js";
+import { normalizeTags, normalizeScopes } from "../tag-registry.js";
+import { redactSecrets } from "../redact.js";
+import { appendLog, gitCommit, listPages, readIndex, readPage, writePage, type WikiPage } from "../wiki.js";
+import type { WikiReadDetails, WikiWriteDetails } from "./schemas.js";
+import { parsePagePath, scheduleWikiMaintenance } from "./shared.js";
+
+// -- Factory: wiki_read execute ----------------------------------------------
+
+export function createEditExecute(
+  wikiDir: string,
+  store: QMDStore,
+  markDirty: () => void,
+) {
+  return async (
+    params: {
+      path: string;
+      edits: Array<{ oldText: string; newText: string }>;
+      title?: string;
+      scope?: string[];
+      tags?: string[];
+      logSummary?: string;
+    },
+  ): Promise<AgentToolResult<WikiWriteDetails>> => {
+    const parsed = parsePagePath(params.path);
+    if (!parsed) {
+      return {
+        content: [{ type: "text", text: `Invalid page path: ${params.path}` }],
+        details: { pagesWritten: [], pagesSkipped: [params.path], indexUpdated: false, logAppended: false },
+      };
+    }
+
+    const existing = await readPage(wikiDir, parsed.category, parsed.slug);
+    const pagePath = `${parsed.category}/${parsed.slug}`;
+    if (!existing) {
+      return {
+        content: [{ type: "text", text: `Page not found: ${pagePath}` }],
+        details: { pagesWritten: [], pagesSkipped: [pagePath], indexUpdated: false, logAppended: false },
+      };
+    }
+
+    if (params.edits.length === 0) {
+      return {
+        content: [{ type: "text", text: "No edits supplied." }],
+        details: { pagesWritten: [], pagesSkipped: [pagePath], indexUpdated: false, logAppended: false },
+      };
+    }
+
+    // Atomic validation: all oldText strings must exist exactly once before writing.
+    const errors: string[] = [];
+    for (const edit of params.edits) {
+      const first = existing.body.indexOf(edit.oldText);
+      const last = existing.body.lastIndexOf(edit.oldText);
+      if (first === -1) {
+        errors.push(`oldText not found: "${edit.oldText.slice(0, 60)}..."`);
+      } else if (first !== last) {
+        errors.push(`oldText is not unique: "${edit.oldText.slice(0, 60)}..."`);
+      }
+    }
+    if (errors.length > 0) {
+      return {
+        content: [{ type: "text", text: `No changes written.\n${errors.join("\n")}` }],
+        details: { pagesWritten: [], pagesSkipped: [pagePath], indexUpdated: false, logAppended: false },
+      };
+    }
+
+    let editedBody = existing.body;
+    for (const edit of params.edits) {
+      editedBody = editedBody.replace(edit.oldText, edit.newText);
+    }
+
+    // Surgical edit path: do not scan/autolink/rebuild/reindex the whole wiki.
+    // wiki_edit is often called mid-task and must stay fast; broader maintenance
+    // can run via wiki_lint/rebuildIndex or on startup.
+    const linkedBody = redactSecrets(editedBody).text;
+    const now = new Date().toISOString();
+    const rawScope = params.scope ?? existing.frontmatter.scope;
+    const newScope = normalizeScopes(rawScope);
+    const rawTags = params.tags ?? existing.frontmatter.tags;
+    const updatedPage: WikiPage = {
+      category: parsed.category,
+      slug: parsed.slug,
+      frontmatter: {
+        ...existing.frontmatter,
+        title: params.title ?? existing.frontmatter.title,
+        scope: newScope,
+        tags: normalizeTags(rawTags, newScope),
+        updated: now,
+        links: syncFrontmatterLinks(linkedBody),
+      },
+      body: linkedBody,
+    };
+
+    await writePage(wikiDir, updatedPage);
+    if (params.logSummary) {
+      await appendLog(wikiDir, {
+        date: now.split("T")[0],
+        operation: "edit",
+        summary: params.logSummary,
+        pages: [pagePath],
+      });
+    }
+    markDirty();
+    await gitCommit(wikiDir, params.logSummary ?? `wiki_edit: ${pagePath}`);
+    scheduleWikiMaintenance(wikiDir, store, markDirty);
+
+    return {
+      content: [{ type: "text", text: `Edited ${pagePath}. Scheduled background index/search refresh.` }],
+      details: {
+        pagesWritten: [pagePath],
+        pagesSkipped: [],
+        indexUpdated: false,
+        logAppended: !!params.logSummary,
+      },
+    };
+  };
+}
+
+export function createReadExecute(wikiDir: string) {
+  return async (
+    params: { path: string },
+  ): Promise<AgentToolResult<WikiReadDetails>> => {
+    const now = Date.now();
+    const normalizedPath = params.path.trim().toLowerCase().replace(/^\/+/, "");
+
+    if (normalizedPath === "index" || normalizedPath === "index.md" || normalizedPath === "wiki-index") {
+      const index = await readIndex(wikiDir);
+      return {
+        content: [{ type: "text", text: index }],
+        details: { found: true, path: "index.md" },
+      };
+    }
+
+    // Try parsing as category/slug path
+    const parsed = parsePagePath(params.path);
+    if (parsed) {
+      const page = await readPage(wikiDir, parsed.category, parsed.slug);
+      if (page) {
+        const fm = page.frontmatter;
+        const freshness = formatFreshness(fm.updated, now);
+        const header = [
+          `# ${fm.title}`,
+          `PARA: ${fm.para} | Scope: ${fm.scope.join(", ")} | Tags: ${fm.tags.join(", ")}`,
+          `Created: ${fm.created} | Updated: ${fm.updated} | ${freshness}`,
+          fm.sources.length > 0 ? `Sources: ${fm.sources.join(", ")}` : "",
+          fm.links.length > 0 ? `Links: ${fm.links.map((l) => `[[${l}]]`).join(", ")}` : "",
+        ]
+          .filter(Boolean)
+          .join("\n");
+
+        return {
+          content: [{ type: "text", text: `${header}\n\n${page.body}` }],
+          details: { found: true, path: `${parsed.category}/${parsed.slug}` },
+        };
+      }
+    }
+
+    // Try finding by title (case-insensitive search across all pages)
+    const allPages = await listPages(wikiDir);
+    const titleLower = params.path.toLowerCase();
+    for (const ref of allPages) {
+      if (ref.title.toLowerCase() === titleLower || ref.slug === titleLower) {
+        const page = await readPage(wikiDir, ref.category, ref.slug);
+        if (page) {
+          const fm = page.frontmatter;
+          const freshness = formatFreshness(fm.updated, now);
+          const header = [
+            `# ${fm.title}`,
+            `PARA: ${fm.para} | Scope: ${fm.scope.join(", ")} | Tags: ${fm.tags.join(", ")}`,
+            `Created: ${fm.created} | Updated: ${fm.updated} | ${freshness}`,
+            fm.sources.length > 0 ? `Sources: ${fm.sources.join(", ")}` : "",
+            fm.links.length > 0 ? `Links: ${fm.links.map((l) => `[[${l}]]`).join(", ")}` : "",
+          ]
+            .filter(Boolean)
+            .join("\n");
+
+          return {
+            content: [{ type: "text", text: `${header}\n\n${page.body}` }],
+            details: { found: true, path: `${ref.category}/${ref.slug}` },
+          };
+        }
+      }
+    }
+
+    return {
+      content: [{ type: "text", text: `Page not found: "${params.path}"` }],
+      details: { found: false },
+    };
+  };
+}

package/src/tools/ingest.ts

@@ -0,0 +1,63 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { QMDStore } from "qmd-engine";
+import type { ProjectScope } from "../scope.js";
+import type { ParaCategory } from "../wiki.js";
+import { resolveSource, truncateSource } from "../ingest.js";
+import { INGEST_PROMPT } from "../templates/prompts.js";
+import type { WikiIngestDetails } from "./schemas.js";
+
+// -- Factory: wiki_ingest execute --------------------------------------------
+
+export function createIngestExecute(
+  wikiDir: string,
+  _store: QMDStore,
+  getScope: () => ProjectScope,
+) {
+  return async (
+    params: { source: string; sourceType?: "url" | "file" | "text"; category?: ParaCategory; scope?: string[] },
+  ): Promise<AgentToolResult<WikiIngestDetails>> => {
+    const scope = getScope();
+    const resolved = await resolveSource(wikiDir, {
+      source: params.source,
+      sourceType: params.sourceType,
+      scope: params.scope,
+      category: params.category,
+    }, scope);
+
+    const categoryHint = resolved.categoryHint
+      ? `\nSuggested PARA category: ${resolved.categoryHint}`
+      : "";
+
+    // Assemble the tool result with instructions for the LLM
+    const toolResultText = [
+      INGEST_PROMPT,
+      "",
+      `Current scope: ${resolved.scopeName} (tags: ${resolved.scopeTags.join(", ")})`,
+      categoryHint,
+      resolved.rawPath ? `Raw source saved to: ${resolved.rawPath}` : "",
+      "",
+      "<wiki-schema>",
+      resolved.schema,
+      "</wiki-schema>",
+      "",
+      "<wiki-index>",
+      resolved.index,
+      "</wiki-index>",
+      "",
+      "<source-content>",
+      truncateSource(resolved.content),
+      "</source-content>",
+      "",
+      "Now analyze the source content and use wiki_write to create/update pages, update the index, and log the operation.",
+    ].join("\n");
+
+    return {
+      content: [{ type: "text", text: toolResultText }],
+      details: {
+        sourceType: resolved.sourceType,
+        rawPath: resolved.rawPath,
+        sourceLength: resolved.content.length,
+      },
+    };
+  };
+}

package/src/tools/lint.ts

@@ -0,0 +1,74 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { QMDStore } from "qmd-engine";
+import { lintWiki } from "../lint.js";
+import { PARA_CATEGORIES } from "../wiki.js";
+import { LINT_PROMPT } from "../templates/prompts.js";
+import type { WikiLintDetails } from "./schemas.js";
+import { scheduleWikiMaintenance } from "./shared.js";
+
+// -- Factory: wiki_lint execute ----------------------------------------------
+
+export function createLintExecute(
+  wikiDir: string,
+  store: QMDStore,
+  markDirty: () => void,
+  getLintConfig?: () => { autoFix: boolean; staleDays: number },
+) {
+  return async (
+    params: { autoFix?: boolean },
+  ): Promise<AgentToolResult<WikiLintDetails>> => {
+    const configured = getLintConfig?.();
+    const report = await lintWiki(wikiDir, {
+      autoFix: params.autoFix ?? configured?.autoFix ?? true,
+      staleDays: configured?.staleDays ?? 90,
+    });
+    if (report.fixed.length > 0) {
+      scheduleWikiMaintenance(wikiDir, store, markDirty);
+    }
+
+    const { issues, fixed, stats } = report;
+
+    // Format report for the LLM
+    const parts: string[] = [];
+
+    parts.push("## Wiki Lint Report\n");
+    parts.push(`Total pages: ${stats.totalPages}`);
+    parts.push(
+      `By category: ${PARA_CATEGORIES.map((c) => `${c}: ${stats.byCategory[c]}`).join(", ")}`,
+    );
+    parts.push(`Total links: ${stats.totalLinks} (broken: ${stats.brokenLinks})`);
+    parts.push(`Orphan pages: ${stats.orphanPages}`);
+    if (stats.oldestPage) parts.push(`Oldest page: ${stats.oldestPage}`);
+    if (stats.newestPage) parts.push(`Newest page: ${stats.newestPage}`);
+    if (stats.lastIngest) parts.push(`Last ingest: ${stats.lastIngest}`);
+
+    if (fixed.length > 0) {
+      parts.push(`\n## Auto-fixed (${fixed.length})\n`);
+      for (const f of fixed) {
+        parts.push(`- [${f.severity}] ${f.page ?? ""}: ${f.message}`);
+      }
+    }
+
+    if (issues.length > 0) {
+      parts.push(`\n## Remaining Issues (${issues.length})\n`);
+      for (const issue of issues) {
+        parts.push(
+          `- [${issue.severity}] ${issue.category}${issue.page ? ` (${issue.page})` : ""}: ${issue.message}`,
+        );
+      }
+      parts.push("");
+      parts.push(LINT_PROMPT);
+    } else {
+      parts.push("\nNo remaining issues. Wiki is healthy.");
+    }
+
+    return {
+      content: [{ type: "text", text: parts.join("\n") }],
+      details: {
+        issueCount: issues.length,
+        fixedCount: fixed.length,
+        stats,
+      },
+    };
+  };
+}

package/src/tools/migrate.ts

@@ -0,0 +1,44 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import { CURRENT_SCHEMA_VERSION, migrateToLatest } from "../frontmatter.js";
+import { listPages, readPage, writePage, type PageFrontmatter } from "../wiki.js";
+
+// -- Factory: wiki_migrate execute -------------------------------------------
+
+export function createMigrateExecute(
+  wikiDir: string,
+) {
+  return async (): Promise<AgentToolResult<{ migratedCount: number; totalPages: number }>> => {
+    const allRefs = await listPages(wikiDir);
+    let migratedCount = 0;
+
+    for (const ref of allRefs) {
+      const page = await readPage(wikiDir, ref.category, ref.slug);
+      if (!page) continue;
+
+      const version = page.frontmatter.schemaVersion ?? 1;
+      if (version >= CURRENT_SCHEMA_VERSION) continue;
+
+      const rawObj = page.frontmatter as unknown as Record<string, unknown>;
+      const result = migrateToLatest(rawObj, page.body);
+
+      const migratedFm = result.fm as unknown as PageFrontmatter;
+      migratedFm.updated = new Date().toISOString();
+      await writePage(wikiDir, {
+        category: ref.category,
+        slug: ref.slug,
+        frontmatter: migratedFm,
+        body: result.body,
+      });
+      migratedCount++;
+    }
+
+    const summary = migratedCount > 0
+      ? `Migrated ${migratedCount} page(s) to schema version ${CURRENT_SCHEMA_VERSION}.`
+      : `All ${allRefs.length} page(s) already at schema version ${CURRENT_SCHEMA_VERSION}.`;
+
+    return {
+      content: [{ type: "text", text: summary }],
+      details: { migratedCount, totalPages: allRefs.length },
+    };
+  };
+}

package/src/tools/move.ts

@@ -0,0 +1,79 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { QMDStore } from "qmd-engine";
+import { appendLog, gitCommit, movePage, readPage, rebuildIndex, type PageRef, type ParaCategory } from "../wiki.js";
+import type { WikiMoveDetails } from "./schemas.js";
+import { parsePagePath, scheduleWikiMaintenance } from "./shared.js";
+
+// -- Factory: wiki_move execute ----------------------------------------------
+
+export function createMoveExecute(
+  wikiDir: string,
+  store: QMDStore,
+  markDirty: () => void,
+) {
+  return async (
+    params: { path: string; to: ParaCategory },
+  ): Promise<AgentToolResult<WikiMoveDetails>> => {
+    const parsed = parsePagePath(params.path);
+    if (!parsed) {
+      throw new Error(`Invalid page path: "${params.path}". Expected format: category/slug`);
+    }
+
+    const page = await readPage(wikiDir, parsed.category, parsed.slug);
+    if (!page) {
+      throw new Error(`Page not found: "${params.path}"`);
+    }
+
+    if (parsed.category === params.to) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Page "${params.path}" is already in ${params.to}. No move needed.`,
+          },
+        ],
+        details: { from: params.path, to: `${params.to}/${parsed.slug}` },
+      };
+    }
+
+    const ref: PageRef = {
+      category: parsed.category,
+      slug: parsed.slug,
+      title: page.frontmatter.title,
+      path: `${parsed.category}/${parsed.slug}.md`,
+    };
+
+    await movePage(wikiDir, ref, params.to);
+
+    // Rebuild index.md inline (fast, single-pass); defer QMD reindex to the
+    // debounced background maintenance queue like wiki_write/wiki_edit.
+    await rebuildIndex(wikiDir);
+    scheduleWikiMaintenance(wikiDir, store, markDirty);
+    markDirty();
+
+    // Git commit
+    await gitCommit(wikiDir, `move: ${page.frontmatter.title} → ${params.to}`);
+
+    // Log the move
+    const now = new Date().toISOString();
+    await appendLog(wikiDir, {
+      date: now.split("T")[0],
+      operation: "move",
+      summary: `Moved ${page.frontmatter.title} from ${parsed.category} to ${params.to}`,
+      pages: [`${params.to}/${parsed.slug}`],
+    });
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Moved "${page.frontmatter.title}" from ${parsed.category}/ to ${params.to}/`,
+        },
+      ],
+      details: {
+        from: `${parsed.category}/${parsed.slug}`,
+        to: `${params.to}/${parsed.slug}`,
+      },
+    };
+  };
+}

package/src/tools/query.ts

@@ -0,0 +1,63 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { QMDStore } from "qmd-engine";
+import type { ProjectScope } from "../scope.js";
+import type { ParaCategory } from "../wiki.js";
+import { queryWiki as queryWikiLib, formatQueryResults } from "../query.js";
+import { QUERY_PROMPT } from "../templates/prompts.js";
+import type { WikiQueryDetails } from "./schemas.js";
+
+// -- Factory: wiki_query execute ---------------------------------------------
+
+export function createQueryExecute(
+  _wikiDir: string,
+  store: QMDStore,
+  getScope: () => ProjectScope,
+  getGraphBoost?: () => boolean,
+) {
+  return async (
+    params: { query: string; global?: boolean; category?: ParaCategory; limit?: number },
+  ): Promise<AgentToolResult<WikiQueryDetails>> => {
+    const scope = getScope();
+    const result = await queryWikiLib(store, {
+      query: params.query,
+      global: params.global,
+      category: params.category,
+      limit: params.limit,
+      graphBoost: getGraphBoost?.() ?? true,
+    }, scope);
+
+    if (result.results.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `No wiki pages found for "${params.query}". The wiki may not have content on this topic yet.`,
+          },
+        ],
+        details: {
+          resultCount: 0,
+          scopeUsed: result.wasGlobal ? "global" : scope.name,
+        },
+      };
+    }
+
+    const formatted = formatQueryResults(result.results);
+    const toolResultText = [
+      QUERY_PROMPT,
+      "",
+      `Query: "${params.query}"`,
+      `Scope: ${result.wasGlobal ? "global (all scopes)" : scope.name}`,
+      `Results: ${result.results.length}`,
+      "",
+      formatted,
+    ].join("\n");
+
+    return {
+      content: [{ type: "text", text: toolResultText }],
+      details: {
+        resultCount: result.results.length,
+        scopeUsed: result.wasGlobal ? "global" : scope.name,
+      },
+    };
+  };
+}

package/src/tools/schemas.ts

@@ -0,0 +1,157 @@
+import { StringEnum } from "@earendil-works/pi-ai";
+import { Type } from "typebox";
+import type { LintReport } from "../lint.js";
+
+// -- Parameter schemas -------------------------------------------------------
+
+export const PARA_ENUM = StringEnum(
+  ["projects", "areas", "resources", "archives"] as const,
+  { description: "PARA category" },
+);
+
+export const PARA_ENUM_NO_ARCHIVES = StringEnum(
+  ["projects", "areas", "resources"] as const,
+  { description: "PARA category (archives excluded for new content)" },
+);
+
+export const WikiIngestParams = Type.Object({
+  source: Type.String({ description: "URL, file path, or raw text to ingest" }),
+  sourceType: Type.Optional(
+    StringEnum(["url", "file", "text"] as const, {
+      description: "Source type (auto-detected if omitted)",
+    }),
+  ),
+  category: Type.Optional(PARA_ENUM_NO_ARCHIVES),
+  scope: Type.Optional(
+    Type.Array(Type.String(), { description: "Scope tags for the ingested content" }),
+  ),
+});
+
+export const WikiQueryParams = Type.Object({
+  query: Type.String({ description: "Natural language search query" }),
+  global: Type.Optional(
+    Type.Boolean({ description: "Search all scopes, not just current project" }),
+  ),
+  category: Type.Optional(PARA_ENUM),
+  limit: Type.Optional(
+    Type.Number({ description: "Max results (default 10)" }),
+  ),
+});
+
+export const WikiEditSchema = Type.Object({
+  oldText: Type.String({ description: "Exact text to find in the page body" }),
+  newText: Type.String({ description: "Replacement text" }),
+});
+
+export const WikiWritePageSchema = Type.Object({
+  category: PARA_ENUM,
+  slug: Type.String({ description: "Page slug (lowercase, hyphens)" }),
+  title: Type.String({ description: "Page title" }),
+  scope: Type.Array(Type.String(), { description: "Scope tags" }),
+  tags: Type.Array(Type.String(), { description: "Topic tags" }),
+  body: Type.String({ description: "Page body in markdown (wiki summary format)" }),
+  mode: StringEnum(["create", "replace", "append", "edit"] as const, {
+    description: "Write mode: create new, replace existing, append to existing, or edit specific sections",
+  }),
+  edits: Type.Optional(Type.Array(WikiEditSchema, {
+    description: "For mode=edit: targeted text replacements (oldText→newText). Page must exist.",
+  })),
+});
+
+export const WikiWriteParams = Type.Object({
+  pages: Type.Array(WikiWritePageSchema, {
+    description: "Pages to write or update",
+  }),
+  // DEPRECATED: indexContent is ignored. Index is auto-rebuilt from all pages on disk.
+  // Kept in schema to avoid breaking existing callers.
+  indexContent: Type.Optional(
+    Type.String({ description: "Updated index.md content (full replacement)" }),
+  ),
+  logSummary: Type.Optional(
+    Type.String({ description: "One-line summary for log.md" }),
+  ),
+});
+
+export const WikiEditParams = Type.Object({
+  path: Type.String({ description: "Existing page path (e.g. 'resources/ssl-cert-gotchas')" }),
+  edits: Type.Array(WikiEditSchema, {
+    description: "Atomic exact text replacements. Every oldText must appear exactly once or no changes are written.",
+  }),
+  title: Type.Optional(Type.String({ description: "Optional replacement page title" })),
+  scope: Type.Optional(Type.Array(Type.String(), { description: "Optional replacement scope tags" })),
+  tags: Type.Optional(Type.Array(Type.String(), { description: "Optional replacement topic tags" })),
+  logSummary: Type.Optional(Type.String({ description: "One-line summary for log.md" })),
+});
+
+export const WikiReadParams = Type.Object({
+  path: Type.String({
+    description: "Page path (e.g. 'projects/auth-refactor') or page title",
+  }),
+});
+
+export const WikiMoveParams = Type.Object({
+  path: Type.String({
+    description: "Current page path (e.g. 'projects/auth-refactor')",
+  }),
+  to: PARA_ENUM,
+});
+
+export const WikiLintParams = Type.Object({
+  autoFix: Type.Optional(
+    Type.Boolean({ description: "Auto-fix simple issues (default true)" }),
+  ),
+});
+
+export const WikiMigrateParams = Type.Object({});
+
+export const WikiSummarizeParams = Type.Object({
+  target: Type.String({
+    description: "Page path, category name (e.g. 'projects'), or 'all'",
+  }),
+  depth: Type.Optional(
+    StringEnum(["brief", "detailed"] as const, {
+      description: "Summary depth (default brief)",
+    }),
+  ),
+});
+
+// -- Detail types for tool results -------------------------------------------
+
+export interface WikiIngestDetails {
+  sourceType: "url" | "file" | "text";
+  rawPath?: string;
+  sourceLength: number;
+}
+
+export interface WikiQueryDetails {
+  resultCount: number;
+  scopeUsed: string;
+}
+
+export interface WikiWriteDetails {
+  pagesWritten: string[];
+  indexUpdated: boolean;
+  logAppended: boolean;
+  pagesSkipped?: string[];
+}
+
+export interface WikiReadDetails {
+  found: boolean;
+  path?: string;
+}
+
+export interface WikiMoveDetails {
+  from: string;
+  to: string;
+}
+
+export interface WikiLintDetails {
+  issueCount: number;
+  fixedCount: number;
+  stats: LintReport["stats"];
+}
+
+export interface WikiSummarizeDetails {
+  target: string;
+  pageCount: number;
+}