@treeseed/sdk 0.1.1 → 0.3.0

package/dist/scripts/build-tenant-worker.js

@@ -0,0 +1,36 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { build } from 'esbuild';
+import { loadTreeseedDeployConfig } from '../platform/deploy/config.js';
+import { loadTreeseedManifest } from '../platform/tenant/config.js';
+import { parseSiteConfig } from '../platform/utils/site-config-schema.js';
+import { corePackageRoot } from '../operations/services/runtime-tools.js';
+const tenantRoot = process.cwd();
+const workerEntry = resolve(corePackageRoot, 'dist/worker/forms-worker.js');
+const outFile = resolve(tenantRoot, '.treeseed/generated/worker/index.js');
+function ensureDir(filePath) {
+    mkdirSync(dirname(filePath), { recursive: true });
+}
+function loadSiteConfig(tenantConfig) {
+    const siteConfigPath = resolve(tenantRoot, tenantConfig.siteConfigPath);
+    return parseSiteConfig(readFileSync(siteConfigPath, 'utf8'));
+}
+const tenantConfig = loadTreeseedManifest();
+const siteConfig = loadSiteConfig(tenantConfig);
+const deployConfig = loadTreeseedDeployConfig();
+ensureDir(outFile);
+await build({
+    entryPoints: [workerEntry],
+    outfile: outFile,
+    bundle: true,
+    format: 'esm',
+    platform: 'browser',
+    target: 'es2022',
+    logLevel: 'silent',
+    external: ['cloudflare:sockets'],
+    define: {
+        __TREESEED_SITE_CONFIG__: JSON.stringify(siteConfig),
+        __TREESEED_DEPLOY_CONFIG__: JSON.stringify(deployConfig),
+    },
+});
+writeFileSync(resolve(tenantRoot, '.treeseed/generated/worker/package.json'), '{\n  "type": "module"\n}\n', 'utf8');

package/dist/scripts/cleanup-markdown.js

@@ -0,0 +1,373 @@
+import fsSync from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { unified } from 'unified';
+import remarkFrontmatter from 'remark-frontmatter';
+import remarkGfm from 'remark-gfm';
+import remarkMath from 'remark-math';
+import remarkMdx from 'remark-mdx';
+import remarkParse from 'remark-parse';
+import remarkStringify from 'remark-stringify';
+const __filename = fileURLToPath(import.meta.url);
+const DEFAULT_TARGETS = ['src/content/knowledge', 'src/content/pages', 'src/content/notes'];
+const MARKDOWN_EXTENSIONS = new Set(['.md', '.mdx']);
+export async function normalizeMarkdown(source, options = {}) {
+    const normalizedSource = source.replace(/\r\n?/g, '\n');
+    const { frontmatter, body } = splitFrontmatter(normalizedSource);
+    const preprocessed = preprocessMarkdownBody(body);
+    const isMdxFile = (options.filePath ?? '').toLowerCase().endsWith('.mdx');
+    const processor = unified().use(remarkParse).use(remarkFrontmatter, ['yaml']).use(remarkGfm).use(remarkMath);
+    if (isMdxFile) {
+        processor.use(remarkMdx);
+    }
+    processor.use(remarkStringify, {
+        bullet: '-',
+        closeAtx: false,
+        fences: true,
+        incrementListMarker: true,
+        listItemIndent: 'one',
+        resourceLink: true,
+        rule: '*',
+        ruleRepetition: 3,
+        ruleSpaces: false,
+        setext: false,
+        tightDefinitions: true,
+    });
+    const rendered = postprocessMarkdown(String(await processor.process({ path: options.filePath ?? 'document.md', value: preprocessed }))).trimEnd();
+    const segments = [];
+    if (frontmatter) {
+        segments.push(frontmatter.trimEnd());
+    }
+    if (rendered) {
+        segments.push(rendered);
+    }
+    return `${segments.join('\n\n')}\n`;
+}
+export async function collectMarkdownTargets(inputPaths, cwd = process.cwd()) {
+    const requested = inputPaths.length > 0 ? inputPaths : DEFAULT_TARGETS;
+    const resolved = requested.map((target) => resolveTargetPath(target, cwd));
+    const files = [];
+    for (const target of resolved) {
+        const stats = await safeStat(target);
+        if (!stats) {
+            continue;
+        }
+        if (stats.isFile()) {
+            if (isMarkdownFile(target)) {
+                files.push(target);
+            }
+            continue;
+        }
+        files.push(...(await collectMarkdownFiles(target)));
+    }
+    return [...new Set(files)].sort((left, right) => left.localeCompare(right, undefined, { numeric: true, sensitivity: 'base' }));
+}
+async function collectMarkdownFiles(rootPath) {
+    const entries = await fs.readdir(rootPath, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path.join(rootPath, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await collectMarkdownFiles(fullPath)));
+            continue;
+        }
+        if (entry.isFile() && isMarkdownFile(fullPath)) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function isMarkdownFile(filePath) {
+    return MARKDOWN_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+async function safeStat(targetPath) {
+    try {
+        return await fs.stat(targetPath);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveTargetPath(target, cwd) {
+    const directPath = path.resolve(cwd, target);
+    if (path.isAbsolute(target)) {
+        return target;
+    }
+    if (fsSyncExists(directPath)) {
+        return directPath;
+    }
+    if (path.basename(cwd) === 'docs' && target.startsWith('docs/')) {
+        return path.resolve(cwd, target.slice('docs/'.length));
+    }
+    return directPath;
+}
+function fsSyncExists(targetPath) {
+    try {
+        return fsSync.existsSync(targetPath);
+    }
+    catch {
+        return false;
+    }
+}
+function splitFrontmatter(source) {
+    if (!source.startsWith('---\n')) {
+        return { frontmatter: '', body: source };
+    }
+    const closingIndex = source.indexOf('\n---\n', 4);
+    if (closingIndex === -1) {
+        return { frontmatter: '', body: source };
+    }
+    const frontmatter = source.slice(0, closingIndex + 5);
+    const body = source.slice(closingIndex + 5);
+    return { frontmatter, body };
+}
+function preprocessMarkdownBody(body) {
+    const lines = body.split('\n');
+    const output = [];
+    let inFence = false;
+    let fenceMarker = '';
+    let fenceLength = 0;
+    let previousNonBlankType = 'start';
+    for (const originalLine of lines) {
+        const line = originalLine.trimEnd();
+        const trimmed = line.trim();
+        if (inFence) {
+            pushLine(output, line);
+            if (isFenceClose(line, fenceMarker, fenceLength)) {
+                inFence = false;
+                previousNonBlankType = 'fence';
+            }
+            continue;
+        }
+        if (trimmed === '') {
+            pushBlankLine(output);
+            continue;
+        }
+        if (isFenceOpen(line)) {
+            if (needsBlankLineBefore(previousNonBlankType)) {
+                pushBlankLine(output);
+            }
+            pushLine(output, line);
+            ({ marker: fenceMarker, length: fenceLength } = getFenceInfo(line));
+            inFence = true;
+            previousNonBlankType = 'fence';
+            continue;
+        }
+        const lineType = classifyLine(line);
+        const previousLine = output.length > 0 ? findPreviousNonBlankLine(output) : '';
+        if (requiresBlankLineBetween(previousNonBlankType, lineType, previousLine, line)) {
+            pushBlankLine(output);
+        }
+        pushLine(output, line);
+        previousNonBlankType = lineType;
+    }
+    return collapseBlankLines(output).join('\n').trim();
+}
+function classifyLine(line) {
+    if (isTableLine(line))
+        return 'table';
+    if (/^\s{0,3}#{1,6}\s+\S/.test(line))
+        return 'heading';
+    if (/^\s{0,3}(?:[-*_])(?:\s*\1){2,}\s*$/.test(line))
+        return 'rule';
+    if (/^\s{0,3}>\s?/.test(line))
+        return 'blockquote';
+    if (/^\s{0,3}(?:[-+*]|\d+[.)])\s+/.test(line))
+        return 'list';
+    if (/^\s*<(?:[A-Za-z][^>]*)>\s*$/.test(line))
+        return 'html';
+    if (/^\s*(?:import|export)\s.+$/.test(line))
+        return 'mdx';
+    if (/^\s*<\/?[A-Z][^>]*>\s*$/.test(line))
+        return 'mdx';
+    return 'prose';
+}
+function isTableLine(line) {
+    const trimmed = line.trim();
+    return /^\|.*\|\s*$/.test(trimmed) || /^[:\-|\s]+$/.test(trimmed);
+}
+function isFenceOpen(line) {
+    return /^\s{0,3}(```+|~~~+)/.test(line);
+}
+function getFenceInfo(line) {
+    const match = line.match(/^\s{0,3}(```+|~~~+)/);
+    return {
+        length: match?.[1]?.length ?? 3,
+        marker: match?.[1]?.[0] ?? '`',
+    };
+}
+function isFenceClose(line, marker, requiredLength) {
+    return new RegExp(`^\\s{0,3}${escapeRegExp(marker)}{${requiredLength},}\\s*$`).test(line);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function needsBlankLineBefore(previousType) {
+    return !['start', 'blank'].includes(previousType);
+}
+function requiresBlankLineBetween(previousType, currentType, previousLine, currentLine) {
+    if (previousType === 'start')
+        return false;
+    if (previousType === 'table' && currentType === 'table')
+        return false;
+    if (previousType === 'blockquote' && currentType === 'blockquote')
+        return false;
+    if (previousType === 'mdx' && currentType === 'mdx')
+        return false;
+    if (previousType === 'html' && currentType === 'prose' && /^\s*<a\b/i.test(currentLine))
+        return false;
+    if (previousType === 'prose' && currentType === 'prose' && looksLikeParagraphBoundary(previousLine, currentLine))
+        return true;
+    if (currentType === 'heading' || currentType === 'rule' || currentType === 'blockquote')
+        return true;
+    if (previousType === 'heading')
+        return true;
+    if (previousType === 'rule')
+        return true;
+    if (previousType === 'table' && currentType !== 'table')
+        return true;
+    if (previousType === 'list' && currentType === 'prose')
+        return true;
+    if (previousType === 'list' && ['heading', 'rule', 'table', 'html', 'mdx'].includes(currentType))
+        return true;
+    if (previousType === 'prose' && ['list', 'table', 'html', 'mdx'].includes(currentType))
+        return true;
+    if (['html', 'mdx'].includes(previousType) && currentType === 'prose')
+        return true;
+    return false;
+}
+function findPreviousNonBlankLine(lines) {
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        if (lines[index].trim() !== '') {
+            return lines[index];
+        }
+    }
+    return '';
+}
+function pushLine(output, line) {
+    output.push(line);
+}
+function pushBlankLine(output) {
+    if (output.length === 0)
+        return;
+    if (output.at(-1) === '')
+        return;
+    output.push('');
+}
+function collapseBlankLines(lines) {
+    const collapsed = [];
+    for (const line of lines) {
+        if (line === '' && collapsed.at(-1) === '') {
+            continue;
+        }
+        collapsed.push(line);
+    }
+    return collapsed;
+}
+function postprocessMarkdown(content) {
+    return content
+        .replace(/\[\\\[(\d+)\\\]\]\(#ref-\1\)/g, '[[$1]](#ref-$1)')
+        .replace(/<a([^>]*?)\s*\/>/g, '<a$1></a>');
+}
+function looksLikeParagraphBoundary(previousLine, currentLine) {
+    const previous = previousLine.trim();
+    const current = currentLine.trim();
+    if (!previous || !current) {
+        return false;
+    }
+    if (/^\*\*\d+\./.test(current) || /^\*[^*]+:\*/.test(current)) {
+        return true;
+    }
+    if (/^\*\*.*\*\*$/.test(previous) && /^\*[^*]+:\*/.test(current)) {
+        return true;
+    }
+    return endsLikeStandaloneParagraph(previous) && startsLikeStandaloneParagraph(current);
+}
+function endsLikeStandaloneParagraph(line) {
+    return /(?:[.!?]["')\]]*|\*{1,2}|\d)\s*$/.test(line);
+}
+function startsLikeStandaloneParagraph(line) {
+    return /^(?:[A-Z0-9]|\*\*|\*[^*]+:\*|\[|["'(])/.test(line);
+}
+function parseArgs(argv) {
+    const args = { check: false, write: false, targets: [] };
+    for (const arg of argv) {
+        if (arg === '--check') {
+            args.check = true;
+            continue;
+        }
+        if (arg === '--write') {
+            args.write = true;
+            continue;
+        }
+        if (arg === '--help' || arg === '-h') {
+            args.help = true;
+            continue;
+        }
+        args.targets.push(arg);
+    }
+    if (!args.check && !args.write) {
+        args.write = true;
+    }
+    return args;
+}
+function printHelp() {
+    console.log(`Usage: node scripts/cleanup-markdown.mjs [--check|--write] [paths...]
+
+Normalizes Markdown/MDX files for public docs readability.
+
+Examples:
+  npm run cleanup:markdown --workspace docs -- src/content/knowledge/research
+  npm run cleanup:markdown:check --workspace docs -- src/content/pages/status.mdx
+`);
+}
+async function runCli(argv = process.argv.slice(2)) {
+    const args = parseArgs(argv);
+    if (args.help) {
+        printHelp();
+        return 0;
+    }
+    if (args.check && args.write) {
+        console.error('Choose either --check or --write, not both.');
+        return 1;
+    }
+    const mode = args.check ? 'check' : 'write';
+    const targets = await collectMarkdownTargets(args.targets);
+    if (targets.length === 0) {
+        console.error('No Markdown files found for cleanup.');
+        return 1;
+    }
+    const changedFiles = [];
+    for (const filePath of targets) {
+        const original = await fs.readFile(filePath, 'utf8');
+        const normalized = await normalizeMarkdown(original, { filePath });
+        if (normalized === original) {
+            continue;
+        }
+        changedFiles.push(filePath);
+        if (mode === 'write') {
+            await fs.writeFile(filePath, normalized, 'utf8');
+        }
+    }
+    if (mode === 'check') {
+        if (changedFiles.length > 0) {
+            console.error('Markdown cleanup needed in:');
+            for (const filePath of changedFiles) {
+                console.error(`- ${path.relative(process.cwd(), filePath)}`);
+            }
+            return 1;
+        }
+        console.log(`Markdown cleanup check passed for ${targets.length} file(s).`);
+        return 0;
+    }
+    console.log(changedFiles.length > 0
+        ? `Normalized ${changedFiles.length} Markdown file(s).`
+        : `No Markdown changes needed across ${targets.length} file(s).`);
+    return 0;
+}
+if (process.argv[1] === __filename) {
+    const exitCode = await runCli();
+    process.exit(exitCode);
+}

package/dist/scripts/cli-test-fixtures.js

@@ -0,0 +1,48 @@
+import { cpSync, mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const scriptsRoot = dirname(fileURLToPath(import.meta.url));
+const cliRoot = resolve(scriptsRoot, '..');
+const sharedFixtureRoot = resolve(cliRoot, '.fixtures', 'treeseed-fixtures', 'sites', 'working-site');
+
+export function makeWorkspaceRoot() {
+	const root = mkdtempSync(join(tmpdir(), 'treeseed-help-workspace-'));
+	writeFileSync(resolve(root, 'package.json'), JSON.stringify({
+		name: 'help-test',
+		private: true,
+		workspaces: ['packages/*'],
+	}, null, 2));
+	writeFileSync(resolve(root, 'treeseed.site.yaml'), `name: Help Test
+slug: help-test
+siteUrl: https://example.com
+contactEmail: hello@example.com
+cloudflare:
+  accountId: account-123
+`, 'utf8');
+	return root;
+}
+
+export function makeTenantWorkspace(branch = 'staging') {
+	const root = makeWorkspaceRoot();
+	cpSync(sharedFixtureRoot, root, { recursive: true });
+	mkdirSync(resolve(root, 'packages', 'placeholder'), { recursive: true });
+	writeFileSync(resolve(root, 'packages', 'placeholder', 'package.json'), JSON.stringify({
+		name: '@test/placeholder',
+		version: '0.0.1',
+	}, null, 2));
+	spawnSync('git', ['init', '-b', branch], { cwd: root, stdio: 'ignore' });
+	spawnSync('git', ['config', 'user.name', 'Treeseed Test'], { cwd: root, stdio: 'ignore' });
+	spawnSync('git', ['config', 'user.email', 'treeseed@example.com'], { cwd: root, stdio: 'ignore' });
+	spawnSync('git', ['add', '-A'], { cwd: root, stdio: 'ignore' });
+	spawnSync('git', ['commit', '-m', 'init'], { cwd: root, stdio: 'ignore' });
+	return root;
+}
+
+export function makeTenantRoot() {
+	const root = mkdtempSync(join(tmpdir(), 'treeseed-cli-test-'));
+	cpSync(sharedFixtureRoot, root, { recursive: true });
+	return root;
+}

package/dist/scripts/config-treeseed.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { collectCliPreflight } from '../operations/services/workspace-preflight.js';
+import { applyTreeseedEnvironmentToProcess, ensureTreeseedGitignoreEntries, getTreeseedMachineConfigPaths, rotateTreeseedMachineKey, runTreeseedConfigWizard, writeTreeseedLocalEnvironmentFiles, } from '../operations/services/config-runtime.js';
+const tenantRoot = process.cwd();
+function parseArgs(argv) {
+    const parsed = {
+        scopes: [],
+        sync: 'all',
+        rotateMachineKey: false,
+    };
+    const rest = [...argv];
+    while (rest.length) {
+        const current = rest.shift();
+        if (!current) {
+            continue;
+        }
+        if (current === '--environment') {
+            parsed.scopes.push(rest.shift() ?? '');
+            continue;
+        }
+        if (current.startsWith('--environment=')) {
+            parsed.scopes.push(current.split('=', 2)[1] ?? '');
+            continue;
+        }
+        if (current === '--sync') {
+            parsed.sync = rest.shift() ?? 'all';
+            continue;
+        }
+        if (current.startsWith('--sync=')) {
+            parsed.sync = current.split('=', 2)[1] ?? 'all';
+            continue;
+        }
+        if (current === '--rotate-machine-key') {
+            parsed.rotateMachineKey = true;
+            continue;
+        }
+        throw new Error(`Unknown config argument: ${current}`);
+    }
+    return parsed;
+}
+const options = parseArgs(process.argv.slice(2));
+const scopes = options.scopes.length === 0 || options.scopes.includes('all')
+    ? ['local', 'staging', 'prod']
+    : ['local', 'staging', 'prod'].filter((scope) => options.scopes.includes(scope));
+ensureTreeseedGitignoreEntries(tenantRoot);
+const preflight = collectCliPreflight({ cwd: tenantRoot, requireAuth: false });
+const rl = readline.createInterface({ input, output });
+try {
+    console.log('Treeseed configuration wizard');
+    console.log('This command writes a local machine config, generates .env.local and .dev.vars, and can sync GitHub or Cloudflare settings.');
+    console.log('Enter a value to set it, press Enter to keep the current/default value, or enter "-" to clear a value.\n');
+    if (options.rotateMachineKey) {
+        const result = rotateTreeseedMachineKey(tenantRoot);
+        console.log('Treeseed machine key rotated.');
+        console.log(`Machine key: ${result.keyPath}`);
+    }
+    else {
+        const result = await runTreeseedConfigWizard({
+            tenantRoot,
+            scopes,
+            sync: options.sync,
+            authStatus: preflight.checks.auth,
+            prompt: async (message) => {
+                if (!process.stdin.isTTY || !process.stdout.isTTY) {
+                    return '';
+                }
+                try {
+                    return await rl.question(message);
+                }
+                catch {
+                    return '';
+                }
+            },
+        });
+        writeTreeseedLocalEnvironmentFiles(tenantRoot);
+        applyTreeseedEnvironmentToProcess({ tenantRoot, scope: 'local', override: true });
+        const { configPath, keyPath } = getTreeseedMachineConfigPaths(tenantRoot);
+        console.log('\nTreeseed config completed.');
+        console.log(`Machine config: ${configPath}`);
+        console.log(`Machine key: ${keyPath}`);
+        console.log(`Updated values: ${result.updated.length}`);
+        console.log(`Initialized environments: ${result.initialized.length}`);
+        if (result.synced.github) {
+            console.log(`GitHub sync: ${result.synced.github.secrets.length} secrets, ${result.synced.github.variables.length} variables (${result.synced.github.repository})`);
+        }
+        if (result.synced.cloudflare) {
+            console.log(`Cloudflare sync: ${result.synced.cloudflare.secrets.length} secrets, ${result.synced.cloudflare.varsManagedByWranglerConfig.length} vars via Wrangler config`);
+        }
+    }
+}
+finally {
+    rl.close();
+}

package/dist/scripts/ensure-mailpit.js

@@ -0,0 +1,29 @@
+import { spawnSync } from 'node:child_process';
+import { dockerIsAvailable, findRunningMailpitContainer } from '../operations/services/mailpit-runtime.js';
+import { mailpitComposeFile, packageRoot } from '../operations/services/runtime-paths.js';
+if (!dockerIsAvailable()) {
+    console.error('Docker is required for Treeseed form email testing. Start Docker and rerun the Mailpit command.');
+    process.exit(1);
+}
+const existingMailpit = findRunningMailpitContainer();
+if (existingMailpit) {
+    console.log(`Reusing existing Mailpit container "${existingMailpit.name}" on ports 1025 and 8025.`);
+    process.exit(0);
+}
+const result = spawnSync('docker', ['compose', '-f', mailpitComposeFile, 'up', '-d', 'mailpit'], {
+    encoding: 'utf8',
+    cwd: packageRoot,
+    env: { ...process.env },
+});
+if (result.status !== 0) {
+    const reusedMailpit = findRunningMailpitContainer();
+    if (reusedMailpit) {
+        console.log(`Reusing existing Mailpit container "${reusedMailpit.name}" on ports 1025 and 8025.`);
+        process.exit(0);
+    }
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+}
+process.exit(result.status ?? 1);