@oldboydev/sheldon-darwin-arm64 0.2.0 → 0.2.1

package/node_modules/@sheldon/cli/node_modules/@sheldon/web/dist/server.js

@@ -9,6 +9,7 @@ import { OperationsDatabase } from '@sheldon/persistence';
 import { VaultService, vaultPaths } from '@sheldon/vault';
 import { webOpenApi } from './contract.js';
 import { InvalidWebJobRequestError, WebJobService } from './jobs.js';
+import { listWikiPaths, readRawFile, readWikiPage, WikiNotFoundError } from './wiki.js';
 export async function createWebServer(options) {
     const root = resolve(options.vaultRoot);
     const server = fastify({
@@ -55,6 +56,21 @@ export async function createWebServer(options) {
         const params = request.params;
         return options.application.showEntity(entityKind(params.kind), params.slug);
     });
+    server.get('/api/v1/entities/:kind/:slug/wiki', async (request, reply)=>{
+        const params = request.params;
+        return sendWiki(reply, ()=>listWikiPaths(root, entityKind(params.kind), params.slug));
+    });
+    server.get('/api/v1/entities/:kind/:slug/wiki/*', async (request, reply)=>{
+        const params = request.params;
+        return sendWiki(reply, ()=>readWikiPage(root, entityKind(params.kind), params.slug, params['*']));
+    });
+    server.get('/api/v1/entities/:kind/:slug/raw/*', async (request, reply)=>{
+        const params = request.params;
+        return sendWiki(reply, async ()=>{
+            const text = await readRawFile(root, entityKind(params.kind), params.slug, params['*']);
+            return reply.type('text/plain; charset=utf-8').send(text);
+        });
+    });
     server.post('/api/v1/entities/:kind/:slug/archive', async (request)=>{
         const params = request.params;
         requireConfirmation(request.body, `${params.kind}:${params.slug}`);
@@ -224,6 +240,16 @@ async function dashboard(root) {
         database.close();
     }
 }
+async function sendWiki(reply, run) {
+    try {
+        return await run();
+    } catch (error) {
+        if (error instanceof WikiNotFoundError) {
+            return reply.status(404).send(problem(error.code, error.message, error.target, error.recovery));
+        }
+        throw error;
+    }
+}
 function entityKind(value) {
     if (value === 'topic' || value === 'project') return value;
     throw badRequest('A entidade deve ser topic ou project.');

package/node_modules/@sheldon/cli/node_modules/@sheldon/web/dist/wiki-markdown.js

@@ -0,0 +1,75 @@
+export function parseWikiMarkdown(markdown) {
+    const blocks = [];
+    let paragraph = [];
+    const flush = ()=>{
+        if (paragraph.length === 0) return;
+        blocks.push({
+            type: 'paragraph',
+            children: parseInlines(paragraph.join('\n'))
+        });
+        paragraph = [];
+    };
+    for (const line of markdown.replaceAll('\r\n', '\n').split('\n')){
+        const heading = /^(#{1,6})[ \t]+(.+)$/u.exec(line);
+        if (heading) {
+            flush();
+            blocks.push({
+                type: 'heading',
+                level: heading[1].length,
+                children: parseInlines(heading[2])
+            });
+            continue;
+        }
+        if (line.trim() === '') {
+            flush();
+            continue;
+        }
+        paragraph.push(line);
+    }
+    flush();
+    return blocks;
+}
+export function resolveWikiHref(currentPath, href) {
+    const trimmed = href.split('#', 1)[0] ?? href;
+    if (trimmed.startsWith('/') || /^[A-Za-z]:[\\/]/u.test(trimmed) || trimmed.includes('..')) {
+        return trimmed;
+    }
+    const slash = currentPath.replaceAll('\\', '/').lastIndexOf('/');
+    const directory = slash === -1 ? '' : currentPath.slice(0, slash + 1);
+    return `${directory}${trimmed}`.replaceAll(/\/{2,}/gu, '/');
+}
+function parseInlines(text) {
+    const result = [];
+    const expression = /\[([^\]]+)\]\(([^)]+)\)/gu;
+    let last = 0;
+    for (const match of text.matchAll(expression)){
+        const index = match.index ?? 0;
+        if (index > last) result.push({
+            type: 'text',
+            value: text.slice(last, index)
+        });
+        const href = match[2];
+        result.push({
+            type: 'link',
+            href,
+            text: match[1],
+            wiki: isWikiHref(href)
+        });
+        last = index + match[0].length;
+    }
+    if (last < text.length) result.push({
+        type: 'text',
+        value: text.slice(last)
+    });
+    return result.length === 0 ? [
+        {
+            type: 'text',
+            value: text
+        }
+    ] : result;
+}
+function isWikiHref(href) {
+    if (href.length === 0 || href.startsWith('#') || href.startsWith('//')) return false;
+    if (/^[A-Za-z][A-Za-z0-9+.-]*:/u.test(href)) return false;
+    return (href.split('#', 1)[0] ?? href).endsWith('.md');
+}

package/node_modules/@sheldon/cli/node_modules/@sheldon/web/dist/wiki.js

@@ -0,0 +1,175 @@
+import { readdir, readFile, realpath, stat } from 'node:fs/promises';
+import { isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { SearchIndex } from '@sheldon/search';
+import { entityDirectory, VaultService } from '@sheldon/vault';
+import { parse } from 'yaml';
+export class WikiNotFoundError extends Error {
+    code = 'WEB_NOT_FOUND';
+    recovery;
+    target;
+    constructor(message, recovery, target){
+        super(message);
+        this.name = 'WikiNotFoundError';
+        this.recovery = recovery;
+        this.target = target;
+    }
+}
+export async function listWikiPaths(vaultRoot, kind, slug) {
+    const entityRoot = await requireEntityRoot(vaultRoot, kind, slug);
+    const wikiRoot = join(entityRoot, 'wiki');
+    const files = await findMarkdownFiles(wikiRoot);
+    return files.map((file)=>({
+            path: toPosix(join('wiki', relative(wikiRoot, file)))
+        })).sort((left, right)=>comparePaths(left.path, right.path));
+}
+export async function readWikiPage(vaultRoot, kind, slug, requestedPath) {
+    const entityRoot = await requireEntityRoot(vaultRoot, kind, slug);
+    const wikiRoot = join(entityRoot, 'wiki');
+    const relativePath = stripPrefix(requestedPath, 'wiki/');
+    const file = await confinedExistingFile(wikiRoot, relativePath);
+    const content = await readFile(file, 'utf8');
+    const concept = parseConcept(content);
+    const realWikiRoot = await realpath(wikiRoot);
+    const path = toPosix(join('wiki', relative(realWikiRoot, file)));
+    return {
+        ...concept,
+        path,
+        neighbours: await readNeighbours(vaultRoot, kind, slug, path)
+    };
+}
+export async function readRawFile(vaultRoot, kind, slug, requestedPath) {
+    const entityRoot = await requireEntityRoot(vaultRoot, kind, slug);
+    const rawRoot = join(entityRoot, 'raw');
+    const relativePath = stripPrefix(requestedPath, 'raw/');
+    const file = await confinedExistingFile(rawRoot, relativePath);
+    return readFile(file, 'utf8');
+}
+async function requireEntityRoot(vaultRoot, kind, slug) {
+    const vault = await VaultService.discover(vaultRoot);
+    try {
+        await vault.inspectEntity(kind, slug);
+    } catch  {
+        throw new WikiNotFoundError('Entidade não encontrada.', 'Atualize a lista e tente novamente.', `${kind}/${slug}`);
+    }
+    return entityDirectory(vaultRoot, kind, slug);
+}
+async function confinedExistingFile(root, requestedPath) {
+    const target = confinedPath(root, requestedPath);
+    let realRoot;
+    let realTarget;
+    try {
+        realRoot = await realpath(root);
+        realTarget = await realpath(target);
+    } catch  {
+        throw wikiMissing();
+    }
+    if (!isInside(realRoot, realTarget)) throw wikiMissing();
+    const info = await stat(realTarget);
+    if (!info.isFile()) throw wikiMissing();
+    return realTarget;
+}
+function confinedPath(root, requestedPath) {
+    const trimmed = requestedPath.trim();
+    if (trimmed.length === 0 || trimmed.includes('\0') || isAbsolute(trimmed)) {
+        throw wikiMissing();
+    }
+    const target = resolve(root, trimmed);
+    if (!isInside(root, target)) throw wikiMissing();
+    return target;
+}
+function isInside(root, target) {
+    const relativePath = relative(resolve(root), resolve(target));
+    return relativePath !== '' && relativePath !== '..' && !relativePath.startsWith(`..${sep}`) && !isAbsolute(relativePath);
+}
+async function findMarkdownFiles(root) {
+    const found = [];
+    const visit = async (directory)=>{
+        let entries;
+        try {
+            entries = await readdir(directory, {
+                withFileTypes: true
+            });
+        } catch (error) {
+            if (isMissing(error)) return;
+            throw error;
+        }
+        for (const entry of entries){
+            const path = join(directory, entry.name);
+            if (entry.isDirectory()) await visit(path);
+            else if (entry.isFile() && entry.name.endsWith('.md')) found.push(path);
+        }
+    };
+    await visit(root);
+    return found;
+}
+function parseConcept(content) {
+    const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/u.exec(content);
+    let data = {};
+    let body = content;
+    if (match) {
+        const value = parse(match[1]);
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            data = value;
+        }
+        body = content.slice(match[0].length).replace(/^\r?\n/u, '');
+    }
+    return {
+        id: typeof data.id === 'string' ? data.id : '',
+        title: typeof data.title === 'string' ? data.title : '',
+        sources: Array.isArray(data.sources) ? data.sources.filter((item)=>typeof item === 'string') : [],
+        body
+    };
+}
+async function readNeighbours(vaultRoot, kind, slug, path) {
+    let index;
+    try {
+        index = SearchIndex.open(vaultRoot);
+    } catch  {
+        return [];
+    }
+    try {
+        const neighbours = [];
+        for (const relation of index.findRelatedConcepts({
+            kind,
+            slug
+        }, path)){
+            for (const mapped of mapRelation(relation.relation)){
+                neighbours.push({
+                    path: relation.path,
+                    relation: mapped
+                });
+            }
+        }
+        return neighbours;
+    } finally{
+        index.close();
+    }
+}
+function mapRelation(relation) {
+    if (relation === 'outgoing') return [
+        'outgoing'
+    ];
+    if (relation === 'backlink') return [
+        'incoming'
+    ];
+    return [
+        'outgoing',
+        'incoming'
+    ];
+}
+function stripPrefix(path, prefix) {
+    const normalized = path.replaceAll('\\', '/');
+    return normalized.startsWith(prefix) ? normalized.slice(prefix.length) : normalized;
+}
+function toPosix(path) {
+    return path.replaceAll('\\', '/');
+}
+function comparePaths(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function wikiMissing() {
+    return new WikiNotFoundError('Wiki não encontrado.', 'Atualize a lista e tente novamente.', 'Wiki');
+}
+function isMissing(error) {
+    return error instanceof Error && 'code' in error && error.code === 'ENOENT';
+}

package/node_modules/@sheldon/cli/node_modules/@sheldon/web/node_modules/@fastify/static/node_modules/glob/node_modules/path-scurry/node_modules/lru-cache/dist/commonjs/react-native/diagnostics-channel-react-native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics-channel-react-native.d.ts","sourceRoot":"","sources":["../../../src/diagnostics-channel-react-native.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,cAAc,EACpB,MAAM,0BAA0B,CAAA;AACjC,YAAY,EAAE,cAAc,EAAE,OAAO,EAAE,CAAA;AAGvC,eAAO,MAAM,OAAO,EAAY,OAAO,CAAC,OAAO,CAAC,CAAA;AAChD,eAAO,MAAM,OAAO,EAAY,cAAc,CAAC,OAAO,CAAC,CAAA"}

package/node_modules/@sheldon/cli/node_modules/@sheldon/web/node_modules/@fastify/static/node_modules/glob/node_modules/path-scurry/node_modules/lru-cache/dist/commonjs/react-native/diagnostics-channel-react-native.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics-channel-react-native.js","sourceRoot":"","sources":["../../../src/diagnostics-channel-react-native.ts"],"names":[],"mappings":";;;AAQA,MAAM,KAAK,GAAG,EAAE,cAAc,EAAE,KAAK,EAAE,CAAA;AAC1B,QAAA,OAAO,GAAG,KAAyB,CAAA;AACnC,QAAA,OAAO,GAAG,KAAgC,CAAA","sourcesContent":["// this is used in ESM environments that follow the 'react-native' import\n// condition, to avoid even trying to load node:diagnostics_channel\nimport {\n  type Channel,\n  type TracingChannel,\n} from 'node:diagnostics_channel'\nexport type { TracingChannel, Channel }\n\nconst dummy = { hasSubscribers: false }\nexport const metrics = dummy as Channel<unknown>\nexport const tracing = dummy as TracingChannel<unknown>\n"]}

package/node_modules/@sheldon/cli/node_modules/@sheldon/web/node_modules/@fastify/static/node_modules/glob/node_modules/path-scurry/node_modules/lru-cache/dist/commonjs/react-native/diagnostics-channel.d.ts

@@ -0,0 +1,5 @@
+import { type Channel, type TracingChannel } from 'node:diagnostics_channel';
+export type { TracingChannel, Channel };
+export declare const metrics: Channel<unknown>;
+export declare const tracing: TracingChannel<unknown>;
+//# sourceMappingURL=diagnostics-channel-react-native.d.ts.map

package/node_modules/@sheldon/cli/node_modules/@sheldon/web/node_modules/@fastify/static/node_modules/glob/node_modules/path-scurry/node_modules/lru-cache/dist/commonjs/react-native/diagnostics-channel.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tracing = exports.metrics = void 0;
+const dummy = { hasSubscribers: false };
+exports.metrics = dummy;
+exports.tracing = dummy;
+//# sourceMappingURL=diagnostics-channel-react-native.js.map