@fro.bot/wiki-write-core 0.1.2 → 0.1.4

package/dist/markdown-links.js

@@ -2,7 +2,7 @@ import { existsSync } from 'node:fs';
 import { dirname, join, normalize } from 'node:path';
 import process from 'node:process';
 import { findCodeRegions, findRegionAt } from "./code-regions.js";
-const MARKDOWN_LINK_PATTERN = /\[[^\]\n]+\]\(\s*(<[^>\n]+>|[^)\s]+)(?:\s+(?:"[^"\n]*"|'[^'\n]*'|\([^)\n]*\)))?\s*\)/gu;
+import { createInlineLinkFinder } from "./inline-links.js";
 /** Resolve live relative markdown links and report whether their targets exist. */
 export function resolveMarkdownLinks(content, containingFile, options = {}) {
     const links = [];
@@ -11,12 +11,14 @@ export function resolveMarkdownLinks(content, containingFile, options = {}) {
     for (const [lineIndex, line] of content.split('\n').entries()) {
         const currentLineOffset = lineOffset;
         lineOffset += line.length + 1;
-        // The shared global pattern is stateful; every line restarts it and the loop runs it to exhaustion.
-        MARKDOWN_LINK_PATTERN.lastIndex = 0;
-        for (let match = MARKDOWN_LINK_PATTERN.exec(line); match !== null; match = MARKDOWN_LINK_PATTERN.exec(line)) {
-            const target = match[1];
+        // Each line gets its own finder; the loop asks it for the next link at or after `from`.
+        const findLink = createInlineLinkFinder(line);
+        let from = 0;
+        for (let match = findLink(from); match !== undefined; match = findLink(from)) {
+            const { target } = match;
             const matchIndex = match.index;
-            if (target === undefined || (matchIndex > 0 && line[matchIndex - 1] === '!')) {
+            from = matchIndex + match.length;
+            if (matchIndex > 0 && line[matchIndex - 1] === '!') {
                 continue;
             }
             // Code binds tighter than links, so a match that touches a fence or span is literal text.
@@ -24,14 +26,14 @@ export function resolveMarkdownLinks(content, containingFile, options = {}) {
             // after an unclosed bracket in code. Resume after the region the match opened in, or just
             // past its first character when it only closes inside one.
             const matchStart = currentLineOffset + matchIndex;
-            const matchLast = matchStart + match[0].length - 1;
+            const matchLast = matchStart + match.length - 1;
             const openingRegion = findRegionAt(regions, matchStart);
             if (openingRegion !== undefined) {
-                MARKDOWN_LINK_PATTERN.lastIndex = Math.max(openingRegion.end - currentLineOffset, matchIndex + 1);
+                from = Math.max(openingRegion.end - currentLineOffset, matchIndex + 1);
                 continue;
             }
             if (findRegionAt(regions, matchLast) !== undefined) {
-                MARKDOWN_LINK_PATTERN.lastIndex = matchIndex + 1;
+                from = matchIndex + 1;
                 continue;
             }
             const normalizedTarget = target.startsWith('<') && target.endsWith('>') ? target.slice(1, -1) : target;

package/dist/rendering-policy.js

@@ -1,11 +1,25 @@
-const UNSAFE_TAG_PATTERN = /<\/?\s*(?:script|iframe|object|embed|applet|base|form|input|button|textarea|select|option|meta|link|style|template|svg|math)\b[^>]*>/iu;
-const EVENT_HANDLER_PATTERN = /\s+on[a-z][\w:-]*\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/iu;
-const UNSAFE_URI_PATTERN = /\s+(?:href|src|srcset|action|formaction|xlink:href|poster|background|cite)\s*=\s*(?:"\s*|')?(?:javascript|vbscript|data):/iu;
+// A tag is unsafe when its name opens it and a `>` follows anywhere after the name. The pattern stops at the
+// name and `hasUnsafeTag` looks for the `>`: a `[^>]*>` tail rescans the rest of the text from every opening
+// when there is no `>`, which is quadratic in the length of the text.
+const UNSAFE_TAG_OPENING_PATTERN = /<\/?\s*(?:script|iframe|object|embed|applet|base|form|input|button|textarea|select|option|meta|link|style|template|svg|math)\b/iu;
+// Both attribute patterns start at the first whitespace character of a run: a match that starts inside a run also
+// starts at the run's beginning, and without the lookbehind a long run of whitespace is rescanned from every
+// position in it.
+const EVENT_HANDLER_PATTERN = /(?<!\s)\s+on[a-z][\w:-]*\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/iu;
+const UNSAFE_URI_PATTERN = /(?<!\s)\s+(?:href|src|srcset|action|formaction|xlink:href|poster|background|cite)\s*=\s*(?:"\s*|')?(?:javascript|vbscript|data):/iu;
+/**
+ * True when `text` holds an unsafe tag: an opening `<name` or `</name` from the list, then a `>` after the name.
+ * The first opening ends before any later one, so if it has no `>` after it none does.
+ */
+function hasUnsafeTag(text) {
+    const opening = UNSAFE_TAG_OPENING_PATTERN.exec(text);
+    return opening !== null && text.includes('>', opening.index + opening[0].length);
+}
 /** Return save-side findings for HTML that the render policy will strip. */
 export function validateRenderingPolicy(params) {
     const findings = [];
     const renderableMarkdown = maskCodeContent(params.content);
-    if (UNSAFE_TAG_PATTERN.test(renderableMarkdown) ||
+    if (hasUnsafeTag(renderableMarkdown) ||
         EVENT_HANDLER_PATTERN.test(renderableMarkdown) ||
         UNSAFE_URI_PATTERN.test(renderableMarkdown)) {
         findings.push({

package/dist/repo-page-move.js

@@ -14,6 +14,7 @@
  * - `log.md` history and `knowledge/wiki/README.md` are never rewritten.
  */
 import { parseFrontmatterDocument, renderFrontmatterDocument } from "./frontmatter.js";
+import { parseRelatedFlow } from "./line-scanners.js";
 import { appendLogEntry, rebuildWikiIndex, validateWikilinks, WikiIngestError } from "./wiki-ingest.js";
 import { buildPrivateNameTokens, computeRepoSlug } from "./wiki-slug.js";
 import { findWikilinkSpans } from "./wiki-utils.js";
@@ -22,7 +23,6 @@ const LOG_PATH = 'knowledge/log.md';
 const REPOS_DIR = 'knowledge/wiki/repos';
 const WIKI_PAGE_PATTERN = /^knowledge\/wiki\/(?:repos|topics|entities|comparisons)\/[^/]+\.md$/u;
 const RELATED_BLOCK_KEY = /^related:\s*(?:#.*)?$/u;
-const RELATED_FLOW = /^related:\s*\[(.*)\]\s*(?:#.*)?$/u;
 /** Apply a change set to a file map, returning a new map. */
 export function applyPageChanges(files, changes) {
     const next = { ...files };
@@ -301,9 +301,9 @@ function editRelatedText(content, oldSlug, newSlug) {
     if (frontmatter === undefined)
         return undefined;
     const lines = frontmatter.split('\n');
-    const flowIndex = lines.findIndex(line => RELATED_FLOW.test(line));
+    const flowIndex = lines.findIndex(line => parseRelatedFlow(line) !== undefined);
     if (flowIndex !== -1) {
-        const inner = RELATED_FLOW.exec(lines[flowIndex] ?? '')?.[1] ?? '';
+        const inner = parseRelatedFlow(lines[flowIndex] ?? '') ?? '';
         const items = inner.split(',').map(item => item.trim());
         const mapped = dedupe(items.map(item => (stripQuotes(item) === oldSlug ? swapQuoted(item, newSlug) : item)));
         lines[flowIndex] = `related: [${mapped.join(', ')}]`;

package/dist/wiki-ingest.d.ts

@@ -31,6 +31,16 @@ export interface BuildWikiIngestChangesParams {
     trackedMetadataAvailable?: boolean;
     /** System-owned correction state used for post-regeneration survival verification. */
     corrections?: CorrectionsFile;
+    /**
+     * Log entries an agent appended to its own `knowledge/log.md`, derived by the caller. Appended to
+     * the existing log, before this ingest's own summary entry.
+     */
+    agentLogEntries?: string;
+    /**
+     * Pages an agent deleted in a handoff, already removed from `existingFiles`. They join the result's
+     * `deletedPaths`, and a call with only deletions needs no page updates.
+     */
+    handoffDeletedPaths?: readonly string[];
 }
 export interface BuildWikiIngestChangesResult {
     files: Record<string, string>;
@@ -38,9 +48,9 @@ export interface BuildWikiIngestChangesResult {
     findings: readonly WikiLintFinding[];
 }
 export interface WikiIngestWarning {
-    code: 'duplicate-repo-identity' | 'repos-metadata-unavailable';
+    code: 'duplicate-repo-identity' | 'repos-metadata-unavailable' | 'agent-log-entries-dropped';
     node_ids?: string[];
-    reason?: 'read-failed' | 'parse-failed';
+    reason?: 'read-failed' | 'parse-failed' | 'not-append-only';
     slugs?: string[];
 }
 export interface TrackedRepoNodeIdsResult {
@@ -65,6 +75,21 @@ export interface CommitWikiChangesParams {
      *   after that read are caught.
      */
     baseCommitSha?: string;
+    /**
+     * A second, per-path base for a write whose pages were edited by an agent job in an earlier job.
+     * `agentCommitSha` is the data commit that job synced; `paths` are the pages it changed or deleted
+     * (`knowledge/log.md` and `knowledge/index.md` are ignored here: the writer rebuilds both itself).
+     *
+     * Before any write, the commit must resolve and be an ancestor of the branch head, or the call fails
+     * with `HANDOFF_BASE_INVALID`. Every attempt then compares each path on the head it reads with the
+     * same path in that commit's tree, ahead of the `baseCommitSha` check, and fails with
+     * `HANDOFF_PAGE_CHANGED` if any differs: another writer edited or deleted the page since the agent
+     * read it.
+     */
+    handoff?: {
+        agentCommitSha: string;
+        paths: readonly string[];
+    };
     octokit?: OctokitClient;
     maxRetries?: number;
     /**
@@ -82,13 +107,15 @@ export interface RunWikiIngestCliDependencies {
     readonly readCorrections?: typeof readCorrections;
     readonly commitWikiChanges?: typeof commitWikiChanges;
     readonly getChangedWikiPaths?: typeof getChangedWikiPaths;
+    /** Client for reading the agent's base commit; defaults to one built from `GITHUB_TOKEN`. */
+    readonly octokit?: OctokitClient;
 }
 /**
  * Narrow Octokit client type derived from the real `@octokit/rest` SDK.
  * See commit-metadata.ts for the rationale behind deriving rather than handwriting.
  */
 export type OctokitClient = Octokit;
-export type WikiIngestErrorCode = 'INVALID_PAYLOAD' | 'INVALID_PAGE_PATH' | 'INVALID_FRONTMATTER' | 'INVALID_WIKILINK' | 'CORRECTION_ERODED' | 'INVALID_RETRIES' | 'PROTECTED_BRANCH' | 'MISSING_TOKEN' | 'OCTOKIT_LOAD_FAILED' | 'CONFLICT_EXHAUSTED';
+export type WikiIngestErrorCode = 'INVALID_PAYLOAD' | 'INVALID_PAGE_PATH' | 'INVALID_FRONTMATTER' | 'INVALID_WIKILINK' | 'CORRECTION_ERODED' | 'INVALID_RETRIES' | 'PROTECTED_BRANCH' | 'MISSING_TOKEN' | 'OCTOKIT_LOAD_FAILED' | 'CONFLICT_EXHAUSTED' | 'HANDOFF_BASE_INVALID' | 'HANDOFF_PAGE_CHANGED';
 export declare class WikiIngestError extends Error {
     readonly code: WikiIngestErrorCode;
     readonly remediation: string;
@@ -100,6 +127,8 @@ export declare class WikiIngestError extends Error {
         findings?: readonly WikiLintFinding[];
     });
 }
+/** The two wiki files every writer shares. Writers rebuild both from their own sync; a handoff never supplies them. */
+export declare function isSharedWikiFile(path: string): boolean;
 export declare function buildWikiIngestChanges(params: BuildWikiIngestChangesParams): BuildWikiIngestChangesResult;
 /**
  * Commits `params.files` (and removes `params.deletedPaths`) as one commit on the data branch.
@@ -109,6 +138,9 @@ export declare function buildWikiIngestChanges(params: BuildWikiIngestChangesPar
  * when it is omitted), another writer changed it, so the write fails with `CONFLICT_EXHAUSTED` and
  * nothing is written. A ref race (`updateRef` 409, or 422 not-a-fast-forward) re-reads the head and
  * replays the same files on it, up to `maxRetries` attempts, under the same guard.
+ *
+ * With `handoff`, the handed-off paths are checked first on every attempt against the agent's data
+ * commit (`HANDOFF_PAGE_CHANGED`), so a page conflict is never reported as a ref race.
  */
 export declare function commitWikiChanges(params: CommitWikiChangesParams): Promise<CommitWikiChangesResult>;
 export declare function validateWikilinks(files: Record<string, string>): void;
@@ -182,6 +214,12 @@ export declare function parsePorcelainPaths(stdout: string): string[];
  * the four category directories.
  */
 export declare function countWikiPages(paths: string[]): number;
+/**
+ * The log text an agent appended: what its `knowledge/log.md` adds after `knowledge/log.md` at the
+ * commit it started from. `undefined` when the agent changed anything before that point, or the base
+ * log is empty, so there is nothing safe to take. Both inputs are normalized first (LF, one final newline).
+ */
+export declare function deriveAgentLogEntries(baseLog: string, handoffLog: string): string | undefined;
 export declare function runWikiIngestCli(dependencies?: RunWikiIngestCliDependencies): Promise<void>;
 type ReadUtf8File = (path: string, encoding: 'utf8') => Promise<string>;
 export declare function loadTrackedRepoNodeIds(readFileImpl?: ReadUtf8File): Promise<TrackedRepoNodeIdsResult>;