@trypattern/sdk 0.1.38 → 0.1.39

package/dist/bookings.d.ts

@@ -88,13 +88,7 @@ export declare const bookingTables: {
         readonly columns: {
             readonly source: z.ZodString;
             readonly requestId: z.ZodString;
-            readonly kind: z.ZodEnum<{
-                done: "done";
-                accepted: "accepted";
-                declined: "declined";
-                replied: "replied";
-                received: "received";
-            }>;
+            readonly kind: z.ZodString;
         };
         readonly access: {
             readonly read: "server";

package/dist/bookingsStore.d.ts

@@ -305,13 +305,7 @@ export declare const bookings: {
             readonly columns: {
                 readonly source: z.ZodString;
                 readonly requestId: z.ZodString;
-                readonly kind: z.ZodEnum<{
-                    done: "done";
-                    accepted: "accepted";
-                    declined: "declined";
-                    replied: "replied";
-                    received: "received";
-                }>;
+                readonly kind: z.ZodString;
             };
             readonly access: {
                 readonly read: "server";

package/dist/cli/app.js

@@ -26,6 +26,8 @@ import { REQUESTS_USAGE, requests } from "./requests.js";
 import { withStartingValues } from "./startingValues.js";
 import { toolBin } from "./tools.js";
 import { isNewer, latestPattern, newerPattern, updateNote } from "./updates.js";
+import { REPORT_PATH, changelogIn, pendingUpdate, recordUpdate } from "./guidance.js";
+import { PROPOSAL_PATH, instructionsNote, instructionsState, migrateInstructions } from "./instructions.js";
 function dependsOnPattern(directory) {
     try {
         const manifest = JSON.parse(readFileSync(join(directory, 'package.json'), 'utf8'));
@@ -84,6 +86,9 @@ const SCREENSHOT_WORKER = join(SDK_SOURCE, 'cli', `screenshot${SDK_EXTENSION}`);
 const VISUAL_URL_ENV = 'PATTERN_VISUAL_URL';
 const GLOBAL_FLAGS = ['--json', '--help', '-h'];
 const NUDGED_COMMANDS = new Set(['start', 'check', 'publish', 'data']);
+const GUIDED_COMMANDS = new Set(['start', 'check']);
+const SDK_PACKAGE = resolve(SDK_SOURCE, '..');
+const INSTALLED_SDK = join(ROOT, 'node_modules', '@trypattern', 'sdk');
 const VALUE_FLAGS = new Set([
     '--commands',
     '--name',
@@ -403,6 +408,16 @@ progress). New Pattern features on the live site, such as the owner approving ap
 need that publish.`,
         run: update
     },
+    'migrate-instructions': {
+        summary: "Move an older AGENTS.md onto Pattern's guide, keeping what's about this site",
+        details: `Pattern's rules now ship inside Pattern (node_modules/@trypattern/sdk/docs/PATTERN.md), and
+AGENTS.md imports them. This removes the sections of AGENTS.md that are Pattern's old template text,
+unchanged, and keeps everything else. A section that mixes Pattern's rules with this project's files,
+or one of Pattern's sections changed for this project, stays in AGENTS.md with a proposed replacement
+in ${PROPOSAL_PATH}; decide each one, then delete that file. app check and app start say
+"instructions migration incomplete" until it's done. Does nothing once AGENTS.md imports the guide.`,
+        run: instructions
+    },
     versions: {
         summary: 'List the versions that went live, newest first',
         details: 'Each version with its number, whether it went live, when, and who published it. app restore <number> puts one back.',
@@ -1637,12 +1652,56 @@ async function update() {
             text: `✗ pnpm couldn’t install Pattern ${latest}:\n${installed.output.trim().split('\n').slice(-LOG_TAIL_LINES).join('\n')}`
         };
     }
+    const report = recordUpdate(ROOT, changelogIn(INSTALLED_SDK), current, latest);
+    const instructions = instructionsNote(instructionsState(ROOT));
     return {
         code: 0,
-        data: { current, latest, updated: true },
-        text: `✓ Updated Pattern ${current} → ${latest}\n  next  run app migration pattern_${latest.replaceAll('.', '_')} (it writes nothing when Pattern's own tables didn't change), then app check, then app publish --message 'Updated Pattern' (straight away if nothing else is in progress) so the live site gets it`
+        data: { current, latest, updated: true, report: REPORT_PATH },
+        text: [
+            `✓ Updated Pattern ${current} → ${latest}`,
+            '',
+            report,
+            `  saved  ${REPORT_PATH}`,
+            `  next  run app migration pattern_${latest.replaceAll('.', '_')} (it writes nothing when Pattern's own tables didn't change), do what the report says, then app check, then app publish --message 'Updated Pattern' (straight away if nothing else is in progress) so the live site gets it`,
+            ...(instructions === undefined ? [] : [instructions])
+        ].join('\n')
     };
 }
+function instructions() {
+    const result = migrateInstructions(ROOT, join(SDK_PACKAGE, 'docs', 'history', 'agents.json'));
+    if (result.status === 'none') {
+        return {
+            code: 1,
+            data: result,
+            text: '✗ There is no AGENTS.md here to move onto the guide.'
+        };
+    }
+    if (result.removed === 0 && result.proposed === 0) {
+        return {
+            code: 0,
+            data: result,
+            text: result.status === 'proposed'
+                ? `✓ AGENTS.md already imports Pattern's guide. Some sections still need a decision: follow ${PROPOSAL_PATH}, then delete it.`
+                : "✓ AGENTS.md already imports Pattern's guide."
+        };
+    }
+    return {
+        code: 0,
+        data: result,
+        text: [
+            `✓ AGENTS.md now imports Pattern's guide (node_modules/@trypattern/sdk/docs/PATTERN.md); ${result.removed} section${result.removed === 1 ? '' : 's'} of Pattern's old rules removed.`,
+            result.proposed === 0
+                ? '  next  read node_modules/@trypattern/sdk/docs/PATTERN.md now: it replaces the rules you had.'
+                : `  next  ${result.proposed} section${result.proposed === 1 ? '' : 's'} may hold something written for this project: follow ${PROPOSAL_PATH}, then delete it. Read node_modules/@trypattern/sdk/docs/PATTERN.md first: it replaces the rules you had.`
+        ].join('\n')
+    };
+}
+function guidanceNotes() {
+    return [
+        pendingUpdate(ROOT, changelogIn(SDK_PACKAGE), sdkVersion()),
+        instructionsNote(instructionsState(ROOT))
+    ].filter((note) => note !== undefined);
+}
 async function setup() {
     const pins = readPins();
     const haveNode = process.versions.node;
@@ -1796,6 +1855,16 @@ async function main(argv) {
                 };
             }
         }
+        if (GUIDED_COMMANDS.has(name)) {
+            const notes = guidanceNotes();
+            if (notes.length > 0) {
+                outcome = {
+                    ...outcome,
+                    data: { ...outcome.data, guidance: notes },
+                    text: [outcome.text, ...notes].join('\n')
+                };
+            }
+        }
     }
     if (jsonMode) {
         const payload = {

package/dist/cli/guidance.d.ts

@@ -0,0 +1,8 @@
+export declare const GUIDE_PATH = "node_modules/@trypattern/sdk/docs/PATTERN.md";
+export declare const REPORT_PATH: string;
+export declare function changelogIn(directory: string): string;
+export declare function updateReport(path: string, from: string, to: string): string;
+export declare function patternFolder(root: string): string;
+export declare function recordUpdate(root: string, changelogPath: string, from: string, to: string): string;
+export declare function updatedNote(from: string, to: string): string;
+export declare function pendingUpdate(root: string, changelogPath: string, current: string): string | undefined;

package/dist/cli/guidance.js

@@ -0,0 +1,121 @@
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { isNewer } from "./updates.js";
+export const GUIDE_PATH = 'node_modules/@trypattern/sdk/docs/PATTERN.md';
+export const REPORT_PATH = join('.pattern', 'update-report.md');
+const SEEN_PATH = join('.pattern', 'update.json');
+const visualChange = z.object({
+    what: z.string(),
+    before: z.string(),
+    after: z.string(),
+    keep: z.string()
+});
+const release = z.object({
+    version: z.string(),
+    added: z.array(z.string()),
+    changed: z.array(z.string()),
+    visual: z.array(visualChange),
+    migrations: z.array(z.string())
+});
+const changelog = z.object({ versions: z.array(release) });
+const seen = z.object({ reported: z.string() });
+export function changelogIn(directory) {
+    return join(directory, 'docs', 'CHANGELOG.json');
+}
+function readJson(path) {
+    try {
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+function releasesBetween(path, from, to) {
+    const parsed = changelog.safeParse(readJson(path));
+    if (!parsed.success)
+        return [];
+    return parsed.data.versions
+        .filter((entry) => isNewer(entry.version, from) && !isNewer(entry.version, to))
+        .sort((a, b) => isNewer(a.version, b.version) ? 1 : isNewer(b.version, a.version) ? -1 : 0);
+}
+function listed(heading, releases, lines) {
+    const items = releases.flatMap((entry) => lines(entry).map((line) => `- ${entry.version} · ${line}`));
+    return items.length === 0 ? [] : [`## ${heading}`, '', ...items, ''];
+}
+export function updateReport(path, from, to) {
+    const releases = releasesBetween(path, from, to);
+    return [
+        `# Pattern ${from} → ${to}`,
+        '',
+        `Pattern was updated. Reread ${GUIDE_PATH} and the references you rely on: they changed with Pattern, and what you remember of them is from ${from}.`,
+        '',
+        ...listed('Do these now', releases, (entry) => entry.migrations),
+        ...(releases.some((entry) => entry.migrations.length > 0)
+            ? [
+                'Then run app check, and publish when nothing else is in progress.',
+                ''
+            ]
+            : []),
+        ...listed('Looks different', releases, (entry) => entry.visual.map((change) => `${change.what}: ${change.before} Now: ${change.after}${change.keep === '' ? '' : ` To keep the old look: ${change.keep}`}`)),
+        ...listed('New', releases, (entry) => entry.added),
+        ...listed('Changed', releases, (entry) => entry.changed),
+        ...(releases.length === 0
+            ? ['Nothing in this update needs anything from you.', '']
+            : [])
+    ].join('\n');
+}
+export function patternFolder(root) {
+    const folder = join(root, '.pattern');
+    mkdirSync(folder, { recursive: true });
+    writeFileSync(join(folder, '.gitignore'), '*\n');
+    return folder;
+}
+function remember(root, version) {
+    patternFolder(root);
+    writeFileSync(join(root, SEEN_PATH), `${JSON.stringify({ reported: version }, null, 2)}\n`);
+}
+export function recordUpdate(root, changelogPath, from, to) {
+    const report = updateReport(changelogPath, from, to);
+    patternFolder(root);
+    writeFileSync(join(root, REPORT_PATH), report);
+    remember(root, to);
+    return report;
+}
+function committedVersion(root) {
+    const shown = spawnSync('git', ['show', 'HEAD:package.json'], {
+        cwd: root,
+        encoding: 'utf8'
+    });
+    if (shown.status !== 0)
+        return undefined;
+    try {
+        const manifest = JSON.parse(shown.stdout);
+        const dependencies = Reflect.get(Object(manifest), 'dependencies');
+        const version = Reflect.get(Object(dependencies), '@trypattern/sdk');
+        const exact = typeof version === 'string' ? version.replace(/^[\^~]/, '') : '';
+        return /^\d+\.\d+\.\d+/.test(exact) ? exact : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function updatedNote(from, to) {
+    return `  updated  Pattern ${from} → ${to}. Read ${REPORT_PATH} (what's new, what looks different and what to do now), do what it says, and reread ${GUIDE_PATH}: it changed with Pattern.`;
+}
+export function pendingUpdate(root, changelogPath, current) {
+    const remembered = seen.safeParse(readJson(join(root, SEEN_PATH)));
+    if (remembered.success && !isNewer(current, remembered.data.reported)) {
+        return undefined;
+    }
+    const from = remembered.success
+        ? remembered.data.reported
+        : committedVersion(root);
+    if (from === undefined || !isNewer(current, from)) {
+        remember(root, current);
+        return undefined;
+    }
+    recordUpdate(root, changelogPath, from, current);
+    return updatedNote(from, current);
+}

package/dist/cli/instructions.d.ts

@@ -0,0 +1,21 @@
+export declare const GUIDE_IMPORT = "@node_modules/@trypattern/sdk/docs/PATTERN.md";
+export declare const PROPOSAL_PATH: string;
+type Section = {
+    raw: string;
+    text: string;
+    normalized: string;
+};
+export type InstructionsState = 'none' | 'migrated' | 'proposed' | 'old';
+export declare function sectionsOf(markdown: string): Section[];
+export declare function instructionsState(root: string): InstructionsState;
+export declare function instructionsNote(state: InstructionsState): string | undefined;
+export declare function migrateInstructions(root: string, historyPath: string): {
+    status: "none";
+    removed: number;
+    proposed: number;
+} | {
+    status: "migrated" | "proposed";
+    removed: number;
+    proposed: number;
+};
+export {};

package/dist/cli/instructions.js

@@ -0,0 +1,206 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { GUIDE_PATH, patternFolder } from "./guidance.js";
+export const GUIDE_IMPORT = `@${GUIDE_PATH}`;
+export const PROPOSAL_PATH = join('.pattern', 'instructions-migration.md');
+const GUIDE_PARAGRAPH = `Pattern's own rules (how to build, check and publish, and everything Pattern already does) come\nwith Pattern itself, so they stay current when it updates. Read them first, and reread them after\nPattern updates:\n\n${GUIDE_IMPORT}`;
+const PROJECT_PATH = /`(?:src|server|starter|flows|public)\/|`(?:seed|schema)\.ts`|`wrangler\.jsonc`|`pattern\.json`/;
+const owner = z.enum(['pattern', 'project', 'mixed']);
+const history = z.object({
+    openers: z.array(z.object({ prefix: z.string(), owner, reference: z.string() })),
+    sections: z.record(z.string(), owner),
+    sentences: z.array(z.string())
+});
+function hashOf(text) {
+    return createHash('sha256').update(text).digest('hex').slice(0, 16);
+}
+function normalized(text) {
+    const collapsed = text.replace(/\s+/g, ' ').trim();
+    return collapsed.startsWith('- ') ? collapsed.slice(2) : collapsed;
+}
+function sentencesOf(text) {
+    return text.split(/(?<=[.!?;:])\s+/).filter((sentence) => sentence !== '');
+}
+function startsSection(line, previous) {
+    return (line.startsWith('- ') ||
+        /^#{1,6} /.test(line) ||
+        (line !== '' && !/^\s/.test(line) && previous === ''));
+}
+export function sectionsOf(markdown) {
+    const groups = [];
+    let previous = '';
+    for (const line of markdown.split('\n')) {
+        const current = groups.at(-1);
+        if (current === undefined || startsSection(line, previous)) {
+            groups.push([line]);
+        }
+        else {
+            current.push(line);
+        }
+        previous = line;
+    }
+    return groups
+        .map((lines) => `${lines.join('\n')}\n`)
+        .filter((raw) => raw.trim() !== '')
+        .map((raw) => {
+        const text = raw.replace(/\n+$/, '');
+        return { raw, text, normalized: normalized(text) };
+    });
+}
+function readHistory(path) {
+    try {
+        const parsed = history.safeParse(JSON.parse(readFileSync(path, 'utf8')));
+        return parsed.success ? parsed.data : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function openerOf(known, section) {
+    return known.openers.find((entry) => section.normalized.startsWith(entry.prefix));
+}
+function keptSentences(known, section, isEdited) {
+    const template = new Set(known.sentences);
+    return sentencesOf(section.normalized)
+        .filter((sentence) => (isEdited && !template.has(hashOf(sentence))) ||
+        PROJECT_PATH.test(sentence))
+        .join(' ');
+}
+function decide(known, section) {
+    const opener = openerOf(known, section);
+    const recorded = known.sections[hashOf(section.normalized)];
+    if (recorded === 'pattern')
+        return { kind: 'remove' };
+    if (recorded === 'project')
+        return { kind: 'keep' };
+    if (recorded === 'mixed') {
+        return {
+            kind: 'propose',
+            why: 'mixed',
+            reference: opener?.reference ?? 'PATTERN.md',
+            replacement: keptSentences(known, section, false)
+        };
+    }
+    if (opener === undefined || opener.owner === 'project') {
+        return { kind: 'keep' };
+    }
+    return {
+        kind: 'propose',
+        why: 'edited',
+        reference: opener.reference,
+        replacement: keptSentences(known, section, true)
+    };
+}
+function isIntro(section) {
+    return section.text.startsWith('# ') || !/^(?:- |#)/.test(section.text);
+}
+function joined(chunks) {
+    return chunks.reduce((text, chunk) => {
+        const needsGap = text !== '' && !text.endsWith('\n\n') && !chunk.startsWith('- ');
+        return `${text}${needsGap ? '\n' : ''}${chunk}`;
+    }, '');
+}
+function withGuide(kept) {
+    const first = kept.findIndex((section) => !isIntro(section));
+    const at = first === -1 ? kept.length : first;
+    return joined([
+        ...kept.slice(0, at).map((section) => section.raw),
+        `${GUIDE_PARAGRAPH}\n\n`,
+        ...kept.slice(at).map((section) => section.raw)
+    ]).replace(/\n+$/, '\n');
+}
+function proposalFor(proposals) {
+    const items = proposals.flatMap(({ section, decision }, index) => {
+        if (decision.kind !== 'propose')
+            return [];
+        const why = decision.why === 'mixed'
+            ? `This is the old template's text. Its rules now live in Pattern's guide (node_modules/@trypattern/sdk/docs/${decision.reference}); only the lines about this project's own files belong in AGENTS.md.`
+            : `This looks like one of Pattern's old sections, changed for this project. Pattern's version now lives in node_modules/@trypattern/sdk/docs/${decision.reference}; keep only what's true and specific to this project.`;
+        return [
+            `## ${index + 1}. ${section.normalized.slice(0, 60)}…`,
+            '',
+            why,
+            '',
+            'Now in AGENTS.md:',
+            '',
+            '```md',
+            section.text,
+            '```',
+            '',
+            decision.replacement === ''
+                ? 'Proposed: delete it.'
+                : 'Proposed replacement:',
+            '',
+            ...(decision.replacement === ''
+                ? []
+                : ['```md', `- ${decision.replacement}`, '```', ''])
+        ];
+    });
+    return [
+        '# Finish moving AGENTS.md onto Pattern’s guide',
+        '',
+        `app migrate-instructions moved AGENTS.md onto Pattern's guide (${GUIDE_PATH}) and removed the rules Pattern now ships. It kept the sections below, because they may hold something written for this project. For each one, read it next to the guide, then apply the proposal, change it, or keep the section as it is. Check every fact against the project's files before keeping it.`,
+        '',
+        'When every section is decided, delete this file. app check and app start say "instructions migration incomplete" until it is gone.',
+        '',
+        ...items
+    ].join('\n');
+}
+export function instructionsState(root) {
+    const path = join(root, 'AGENTS.md');
+    if (!existsSync(path))
+        return 'none';
+    if (!readFileSync(path, 'utf8').includes(GUIDE_IMPORT))
+        return 'old';
+    return existsSync(join(root, PROPOSAL_PATH)) ? 'proposed' : 'migrated';
+}
+export function instructionsNote(state) {
+    if (state === 'old') {
+        return "  instructions migration incomplete  AGENTS.md still carries Pattern's old rules, so it may say Pattern can't do things it now does. Run app migrate-instructions and follow what it prints.";
+    }
+    if (state === 'proposed') {
+        return `  instructions migration incomplete  Some sections of AGENTS.md need a decision: follow ${PROPOSAL_PATH}, then delete it.`;
+    }
+    return undefined;
+}
+export function migrateInstructions(root, historyPath) {
+    const path = join(root, 'AGENTS.md');
+    const state = instructionsState(root);
+    if (state === 'none') {
+        return { status: 'none', removed: 0, proposed: 0 };
+    }
+    if (state !== 'old') {
+        return { status: state, removed: 0, proposed: 0 };
+    }
+    const known = readHistory(historyPath);
+    if (known === undefined) {
+        throw new Error(`Pattern's instructions history is missing (${historyPath})`);
+    }
+    const decided = sectionsOf(readFileSync(path, 'utf8')).map((section) => ({
+        section,
+        decision: decide(known, section)
+    }));
+    const kept = decided
+        .filter(({ decision }) => decision.kind !== 'remove')
+        .map(({ section }) => section);
+    const proposals = decided.filter(({ decision }) => decision.kind === 'propose');
+    writeFileSync(path, withGuide(kept));
+    if (!existsSync(join(root, 'CLAUDE.md'))) {
+        writeFileSync(join(root, 'CLAUDE.md'), '@AGENTS.md\n');
+    }
+    const proposalPath = join(root, PROPOSAL_PATH);
+    if (proposals.length === 0) {
+        rmSync(proposalPath, { force: true });
+    }
+    else {
+        patternFolder(root);
+        writeFileSync(proposalPath, proposalFor(proposals));
+    }
+    return {
+        status: proposals.length === 0 ? 'migrated' : 'proposed',
+        removed: decided.length - kept.length,
+        proposed: proposals.length
+    };
+}

package/dist/inquiriesStore.d.ts

@@ -56,13 +56,7 @@ export declare const inquiries: {
             readonly columns: {
                 readonly source: z.ZodString;
                 readonly requestId: z.ZodString;
-                readonly kind: z.ZodEnum<{
-                    done: "done";
-                    accepted: "accepted";
-                    declined: "declined";
-                    replied: "replied";
-                    received: "received";
-                }>;
+                readonly kind: z.ZodString;
             };
             readonly access: {
                 readonly read: "server";