@phyzess/pappra 0.0.0-stage → 0.1.0-beta.10

package/dist/workspace/resolve.js

@@ -0,0 +1,268 @@
+import { dirname, join, resolve } from 'node:path';
+import { createDiagnostic } from '../schemas/diagnostics.js';
+import { diagnosticCodes } from '../schemas/errors.js';
+import { isPathInside } from '../schemas/paths.js';
+import { observePath, resolveRealpath } from '../infra/fs.js';
+/** Directory-container check that also accepts a symlinked .pappra inside root. */
+async function usablePappraDirectory(root, path) {
+    const real = await resolveRealpath(path);
+    return real !== null && isPathInside(root, real);
+}
+/**
+ * Walks from an explicit start path (default cwd) to the filesystem root and
+ * returns the nearest registered workspace. It only probes `.pappra` markers,
+ * never scans home or unrelated project content.
+ *
+ * A `.pappra` directory without workspace.json stops the walk: a partial
+ * registration is reported instead of silently falling back to an outer
+ * workspace.
+ */
+export async function resolveWorkspaceRoot(options = {}) {
+    const requestedPath = options.startPath ?? process.cwd();
+    const absolute = resolve(requestedPath);
+    const diagnostics = [];
+    let observation;
+    try {
+        observation = await observePath(absolute);
+    }
+    catch (error) {
+        diagnostics.push(createDiagnostic({
+            code: diagnosticCodes.workspaceStartInvalid,
+            severity: 'error',
+            message: `Cannot inspect the workspace start path: ${absolute} (${error instanceof Error ? error.message : String(error)})`,
+            source: absolute,
+            hint: 'Pass an existing directory path.',
+        }));
+        return {
+            requestedPath,
+            startDirectory: null,
+            state: 'unavailable',
+            root: null,
+            configPath: null,
+            diagnostics,
+        };
+    }
+    if (observation.kind === 'missing') {
+        diagnostics.push(createDiagnostic({
+            code: diagnosticCodes.workspaceStartInvalid,
+            severity: 'error',
+            message: `Workspace start path does not exist: ${absolute}`,
+            source: absolute,
+            hint: 'Pass an existing directory path.',
+        }));
+        return {
+            requestedPath,
+            startDirectory: null,
+            state: 'unavailable',
+            root: null,
+            configPath: null,
+            diagnostics,
+        };
+    }
+    if (observation.kind === 'other') {
+        diagnostics.push(createDiagnostic({
+            code: diagnosticCodes.workspaceStartInvalid,
+            severity: 'error',
+            message: `Workspace start path is not a directory or regular file: ${absolute}`,
+            source: absolute,
+            hint: 'Pass an existing directory path.',
+        }));
+        return {
+            requestedPath,
+            startDirectory: null,
+            state: 'unavailable',
+            root: null,
+            configPath: null,
+            diagnostics,
+        };
+    }
+    let directoryCandidate = absolute;
+    if (observation.kind === 'file') {
+        directoryCandidate = dirname(absolute);
+    }
+    else if (observation.kind === 'symlink') {
+        const target = await resolveRealpath(absolute);
+        const targetObservation = target === null ? null : await observePath(target);
+        if (target === null || targetObservation === null) {
+            diagnostics.push(createDiagnostic({
+                code: diagnosticCodes.workspaceStartInvalid,
+                severity: 'error',
+                message: `Cannot resolve the symlinked workspace start path: ${absolute}`,
+                source: absolute,
+                hint: 'Pass an existing readable directory path.',
+            }));
+            return {
+                requestedPath,
+                startDirectory: null,
+                state: 'unavailable',
+                root: null,
+                configPath: null,
+                diagnostics,
+            };
+        }
+        directoryCandidate =
+            targetObservation.kind === 'file' ? dirname(target) : target;
+    }
+    const startDirectory = await resolveRealpath(directoryCandidate);
+    if (startDirectory === null) {
+        diagnostics.push(createDiagnostic({
+            code: diagnosticCodes.workspaceStartInvalid,
+            severity: 'error',
+            message: `Cannot resolve the workspace start path: ${absolute}`,
+            source: absolute,
+            hint: 'Pass an existing readable directory path.',
+        }));
+        return {
+            requestedPath,
+            startDirectory: null,
+            state: 'unavailable',
+            root: null,
+            configPath: null,
+            diagnostics,
+        };
+    }
+    for (let directory = startDirectory;; directory = dirname(directory)) {
+        const pappraPath = join(directory, '.pappra');
+        const pappraObservation = await observePath(pappraPath);
+        if (pappraObservation.kind !== 'missing') {
+            const usable = pappraObservation.kind === 'directory' ||
+                (pappraObservation.kind === 'symlink' &&
+                    (await usablePappraDirectory(directory, pappraPath)));
+            if (!usable) {
+                diagnostics.push(createDiagnostic({
+                    code: diagnosticCodes.workspaceRegistrationIncomplete,
+                    severity: 'error',
+                    message: `Found ${pappraPath}, but it is not a usable .pappra directory inside the workspace.`,
+                    source: pappraPath,
+                    hint: 'Repair or remove the marker explicitly; Pappra does not fall back to an outer workspace.',
+                }));
+                return {
+                    requestedPath,
+                    startDirectory,
+                    state: 'incomplete',
+                    root: directory,
+                    configPath: null,
+                    diagnostics,
+                };
+            }
+            const configPath = join(pappraPath, 'workspace.json');
+            const configObservation = await observePath(configPath);
+            if (configObservation.kind === 'missing') {
+                diagnostics.push(createDiagnostic({
+                    code: diagnosticCodes.workspaceRegistrationIncomplete,
+                    severity: 'error',
+                    message: `Workspace marker is incomplete: ${configPath} is missing.`,
+                    source: pappraPath,
+                    hint: 'Run pappra init or restore workspace.json. Pappra does not silently use an outer workspace.',
+                }));
+                return {
+                    requestedPath,
+                    startDirectory,
+                    state: 'incomplete',
+                    root: directory,
+                    configPath: null,
+                    diagnostics,
+                };
+            }
+            const configRealpath = await resolveRealpath(configPath);
+            if (configObservation.kind === 'symlink' && configRealpath === null) {
+                diagnostics.push(createDiagnostic({
+                    code: diagnosticCodes.workspaceRegistrationIncomplete,
+                    severity: 'error',
+                    message: `workspace.json is a broken symlink: ${configPath}`,
+                    source: configPath,
+                    hint: 'Restore a readable regular workspace.json; Pappra does not follow broken links.',
+                }));
+                return {
+                    requestedPath,
+                    startDirectory,
+                    state: 'incomplete',
+                    root: directory,
+                    configPath: null,
+                    diagnostics,
+                };
+            }
+            if (configRealpath !== null && !isPathInside(directory, configRealpath)) {
+                diagnostics.push(createDiagnostic({
+                    code: diagnosticCodes.configSymlinkEscape,
+                    severity: 'error',
+                    message: `workspace.json resolves outside the workspace: ${configRealpath}`,
+                    source: configPath,
+                    hint: 'Keep configuration inside this workspace; external symlinks are not followed.',
+                }));
+                return {
+                    requestedPath,
+                    startDirectory,
+                    state: 'incomplete',
+                    root: directory,
+                    configPath: null,
+                    diagnostics,
+                };
+            }
+            if (configObservation.kind === 'symlink' && configRealpath !== null) {
+                const targetObservation = await observePath(configRealpath);
+                if (targetObservation.kind !== 'file') {
+                    diagnostics.push(createDiagnostic({
+                        code: diagnosticCodes.workspaceRegistrationIncomplete,
+                        severity: 'error',
+                        message: `workspace.json symlink does not resolve to a regular file: ${configPath}`,
+                        source: configPath,
+                        hint: 'Replace it with a readable regular file; Pappra does not guess configuration.',
+                    }));
+                    return {
+                        requestedPath,
+                        startDirectory,
+                        state: 'incomplete',
+                        root: directory,
+                        configPath: null,
+                        diagnostics,
+                    };
+                }
+            }
+            if (configObservation.kind !== 'file' &&
+                configObservation.kind !== 'symlink') {
+                diagnostics.push(createDiagnostic({
+                    code: diagnosticCodes.workspaceRegistrationIncomplete,
+                    severity: 'error',
+                    message: `workspace.json is not a regular file: ${configPath}`,
+                    source: configPath,
+                    hint: 'Replace it with a regular JSON file; Pappra does not guess configuration.',
+                }));
+                return {
+                    requestedPath,
+                    startDirectory,
+                    state: 'incomplete',
+                    root: directory,
+                    configPath: null,
+                    diagnostics,
+                };
+            }
+            return {
+                requestedPath,
+                startDirectory,
+                state: 'registered',
+                root: directory,
+                configPath,
+                diagnostics,
+            };
+        }
+        const parent = dirname(directory);
+        if (parent === directory)
+            break;
+    }
+    diagnostics.push(createDiagnostic({
+        code: diagnosticCodes.workspaceNotFound,
+        severity: 'info',
+        message: `No registered Pappra workspace found above ${startDirectory}.`,
+        source: startDirectory,
+        hint: 'Provide an explicit workspace root or run pappra init. Pappra does not scan the home directory for workspaces.',
+    }));
+    return {
+        requestedPath,
+        startDirectory,
+        state: 'missing',
+        root: null,
+        configPath: null,
+        diagnostics,
+    };
+}

package/dist/workspace/types.d.ts

@@ -0,0 +1,71 @@
+import type { Diagnostic } from '../schemas/diagnostics.js';
+import type { RepositoryAccess } from '../schemas/workspace.js';
+import type { GitRepositoryKind, GitRepositoryObservation } from '../infra/git.js';
+export type WorkspaceConfigState = 'valid' | 'missing' | 'invalid';
+export type MachineConfigState = 'valid' | 'missing' | 'invalid';
+export interface DiscoveredRepository {
+    /** Logical id from workspace.json; null for a repository found by scan. */
+    readonly id: string | null;
+    readonly origin: 'workspace-config' | 'scan';
+    readonly external: boolean;
+    readonly access: RepositoryAccess;
+    /** Real absolute checkout path. External mappings may be outside the root. */
+    readonly root: string;
+    /** Workspace-relative POSIX path; null for external or out-of-root checkouts. */
+    readonly relativePath: string | null;
+    /** Original workspace.json path, kept for provenance. */
+    readonly configuredPath: string | null;
+    readonly git: GitRepositoryObservation;
+    readonly kind: GitRepositoryKind;
+    readonly diagnostics: readonly Diagnostic[];
+}
+export interface UnresolvedRepository {
+    readonly id: string;
+    readonly configuredPath: string;
+    readonly diagnostics: readonly Diagnostic[];
+}
+export type DocumentKind = 'rule' | 'documentation' | 'decision-record';
+export type DocumentOrigin = 'workspace-config' | 'well-known' | 'directory-scan' | 'repository-scan';
+export interface DiscoveredDocument {
+    /** Absolute real path; the file was not moved, renamed, or rewritten. */
+    readonly path: string;
+    readonly workspaceRelativePath: string | null;
+    readonly repositoryId: string | null;
+    readonly kind: DocumentKind;
+    readonly origin: DocumentOrigin;
+    /** Config pointer, well-known marker, or scanned directory that produced this entry. */
+    readonly declaredBy: string;
+    readonly sizeBytes: number;
+}
+export interface ValidationCandidate {
+    readonly id: string;
+    readonly origin: 'workspace-config' | 'package-script';
+    readonly repositoryId: string | null;
+    readonly repositoryAccess: RepositoryAccess | null;
+    readonly executable: string;
+    readonly args: readonly string[];
+    readonly workingDirectory: string | null;
+    readonly declaredBy: string;
+    /** How the package runner was chosen; never evidence that it is installed. */
+    readonly runnerSource: 'workspace-config' | 'declared' | 'lockfile' | 'fallback';
+    /**
+     * Discovery never resolves, executes, or trusts these commands. A candidate
+     * is a declaration only, not evidence that the tool or script is usable.
+     */
+    readonly verification: 'not-verified';
+}
+export interface DiscoveryOptions {
+    /** Directory depth below the workspace root; 0 inspects only the root. */
+    readonly scanDepth?: number;
+    readonly maxDirectories?: number;
+    readonly maxDocuments?: number;
+    readonly maxEntriesPerDirectory?: number;
+    readonly gitTimeoutMs?: number;
+}
+export interface NormalizedDiscoveryOptions {
+    readonly scanDepth: number;
+    readonly maxDirectories: number;
+    readonly maxDocuments: number;
+    readonly maxEntriesPerDirectory: number;
+    readonly gitTimeoutMs: number;
+}

package/dist/workspace/types.js

@@ -0,0 +1 @@
+export {};

package/dist/workspace/validation.d.ts

@@ -0,0 +1,18 @@
+import type { Diagnostic } from '../schemas/diagnostics.js';
+import type { WorkspaceConfig } from '../schemas/workspace.js';
+import type { DiscoveredRepository, ValidationCandidate } from './types.js';
+export interface ValidationDiscoveryInput {
+    readonly root: string;
+    readonly config: WorkspaceConfig | null;
+    readonly configPath: string;
+    readonly repositories: readonly DiscoveredRepository[];
+}
+export interface ValidationDiscoveryOutput {
+    readonly candidates: readonly ValidationCandidate[];
+    readonly diagnostics: readonly Diagnostic[];
+}
+/**
+ * Reports validation commands declared in workspace.json and package.json.
+ * Nothing is resolved on PATH or executed.
+ */
+export declare function discoverValidationCandidates(input: ValidationDiscoveryInput): Promise<ValidationDiscoveryOutput>;

package/dist/workspace/validation.js

@@ -0,0 +1,197 @@
+import { join } from 'node:path';
+import { z } from 'zod';
+import { createDiagnostic, pointer } from '../schemas/diagnostics.js';
+import { diagnosticCodes } from '../schemas/errors.js';
+import { observePath, readTextFileBounded } from '../infra/fs.js';
+const packageManifestSchema = z.object({
+    packageManager: z.string().min(1).max(128).optional(),
+    scripts: z.record(z.string(), z.string()).optional(),
+});
+const knownRunners = new Set(['pnpm', 'npm', 'yarn', 'bun']);
+const validationScriptPattern = /^(?:test|lint|typecheck|check|verify|validate)(?::|$)/;
+function declaredRunner(packageManager) {
+    if (packageManager === undefined)
+        return null;
+    const name = packageManager.split('@')[0] ?? '';
+    if (!knownRunners.has(name))
+        return 'unsupported';
+    return { name, source: 'declared' };
+}
+async function detectRunner(directory, packageManager, diagnostics, manifestPath) {
+    const declared = declaredRunner(packageManager);
+    if (declared === 'unsupported') {
+        diagnostics.push(createDiagnostic({
+            code: diagnosticCodes.validationRunnerUnsupported,
+            severity: 'warning',
+            message: `Declared package manager "${packageManager}" is not supported for validation candidates.`,
+            source: manifestPath,
+            pointer: pointer('packageManager'),
+            hint: 'Pappra reports no package-script candidates instead of guessing a different runner.',
+        }));
+        return null;
+    }
+    if (declared !== null)
+        return declared;
+    const candidates = [
+        ['pnpm-lock.yaml', 'pnpm'],
+        ['pnpm-workspace.yaml', 'pnpm'],
+        ['yarn.lock', 'yarn'],
+        ['bun.lock', 'bun'],
+        ['bun.lockb', 'bun'],
+        ['package-lock.json', 'npm'],
+    ];
+    const found = [];
+    for (const [file, runner] of candidates) {
+        const observation = await observePath(join(directory, file));
+        if (observation.kind === 'file' && !found.includes(runner)) {
+            found.push(runner);
+        }
+    }
+    if (found.length > 1) {
+        diagnostics.push(createDiagnostic({
+            code: diagnosticCodes.validationRunnerAmbiguous,
+            severity: 'warning',
+            message: `Multiple package-manager lockfiles were found: ${found.join(', ')}.`,
+            source: manifestPath,
+            hint: `Discovery used ${found[0] ?? 'npm'} without executing any script; declare packageManager to remove the ambiguity.`,
+        }));
+    }
+    const selected = found[0];
+    return selected === undefined
+        ? { name: 'npm', source: 'fallback' }
+        : { name: selected, source: 'lockfile' };
+}
+/**
+ * Reports validation commands declared in workspace.json and package.json.
+ * Nothing is resolved on PATH or executed.
+ */
+export async function discoverValidationCandidates(input) {
+    const { root, config, configPath, repositories } = input;
+    const candidates = [];
+    const diagnostics = [];
+    if (config !== null) {
+        for (const [index, validation] of config.validation.entries()) {
+            const repository = repositories.find((item) => item.id === validation.repositoryId);
+            if (repository === undefined) {
+                diagnostics.push(createDiagnostic({
+                    code: diagnosticCodes.validationCandidateUnbound,
+                    severity: 'warning',
+                    message: `Validation "${validation.id}" is declared for repository "${validation.repositoryId}", but that checkout was not discovered.`,
+                    source: configPath,
+                    pointer: pointer('validation', index, 'repositoryId'),
+                    hint: 'Fix the repository path or mapping before treating this command as runnable.',
+                }));
+            }
+            candidates.push({
+                id: `workspace-config:${validation.id}`,
+                origin: 'workspace-config',
+                repositoryId: validation.repositoryId,
+                repositoryAccess: repository?.access ?? null,
+                executable: validation.executable,
+                args: validation.args,
+                workingDirectory: repository?.root ?? null,
+                declaredBy: `${configPath}#${pointer('validation', index)}`,
+                runnerSource: 'workspace-config',
+                verification: 'not-verified',
+            });
+        }
+    }
+    const manifestDirectories = new Map();
+    for (const repository of repositories) {
+        manifestDirectories.set(repository.root, repository);
+    }
+    if (!manifestDirectories.has(root)) {
+        manifestDirectories.set(root, null);
+    }
+    for (const [directory, repository] of manifestDirectories) {
+        const manifestPath = join(directory, 'package.json');
+        const observation = await observePath(manifestPath);
+        if (observation.kind === 'missing')
+            continue;
+        if (observation.kind !== 'file') {
+            diagnostics.push(createDiagnostic({
+                code: diagnosticCodes.packageManifestInvalid,
+                severity: 'warning',
+                message: `package.json is not a regular file: ${manifestPath}`,
+                source: manifestPath,
+                hint: 'Discovery skips this manifest and executes nothing.',
+            }));
+            continue;
+        }
+        const read = await readTextFileBounded(manifestPath, 1024 * 1024);
+        if (!read.ok) {
+            diagnostics.push(createDiagnostic({
+                code: diagnosticCodes.packageManifestInvalid,
+                severity: 'warning',
+                message: `Cannot read package.json: ${read.message}`,
+                source: manifestPath,
+                hint: 'Fix the manifest or permissions; no scripts were executed.',
+            }));
+            continue;
+        }
+        let raw;
+        try {
+            raw = JSON.parse(read.value.text);
+        }
+        catch (error) {
+            diagnostics.push(createDiagnostic({
+                code: diagnosticCodes.packageManifestInvalid,
+                severity: 'warning',
+                message: `Invalid package.json: ${error instanceof Error ? error.message : String(error)}`,
+                source: manifestPath,
+                hint: 'Fix the manifest; discovery did not execute or rewrite it.',
+            }));
+            continue;
+        }
+        const parsed = packageManifestSchema.safeParse(raw);
+        if (!parsed.success) {
+            const firstIssue = parsed.error.issues[0];
+            diagnostics.push(createDiagnostic({
+                code: diagnosticCodes.packageManifestInvalid,
+                severity: 'warning',
+                message: `package.json has an unexpected shape: ${firstIssue?.message ?? 'validation failed'}`,
+                source: manifestPath,
+                pointer: firstIssue === undefined
+                    ? null
+                    : pointer(...firstIssue.path.map((item) => String(item))),
+                hint: 'Discovery skipped this manifest; no scripts were executed.',
+            }));
+            continue;
+        }
+        const scripts = parsed.data.scripts;
+        if (scripts === undefined)
+            continue;
+        const runner = await detectRunner(directory, parsed.data.packageManager, diagnostics, manifestPath);
+        if (runner === null)
+            continue;
+        const scriptNames = Object.keys(scripts)
+            .filter((name) => validationScriptPattern.test(name))
+            .sort((left, right) => left.localeCompare(right));
+        for (const name of scriptNames) {
+            if (candidates.length >= 256) {
+                diagnostics.push(createDiagnostic({
+                    code: diagnosticCodes.discoveryLimitReached,
+                    severity: 'warning',
+                    message: 'Validation candidate list reached its 256-entry bound.',
+                    source: manifestPath,
+                    hint: 'Declare only the validation commands needed for this workspace.',
+                }));
+                break;
+            }
+            const scope = repository?.id ?? repository?.relativePath ?? 'workspace';
+            candidates.push({
+                id: `package-script:${scope}:${name}`,
+                origin: 'package-script',
+                repositoryId: repository?.id ?? null,
+                repositoryAccess: repository?.access ?? null,
+                executable: runner.name,
+                args: ['run', name],
+                workingDirectory: directory,
+                declaredBy: `${manifestPath}#${pointer('scripts', name)}`,
+                runnerSource: runner.source,
+                verification: 'not-verified',
+            });
+        }
+    }
+    return { candidates, diagnostics };
+}

package/package.json

@@ -1,6 +1,113 @@
 {
   "name": "@phyzess/pappra",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-beta.10",
+  "description": "Portable workspace knowledge and continuity for coding agents.",
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=24"
+  },
+  "packageManager": "pnpm@12.3.4",
+  "bin": {
+    "pappra": "dist/cli/main.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./collab": {
+      "types": "./dist/collab/index.d.ts",
+      "import": "./dist/collab/index.js"
+    },
+    "./collab/admission": {
+      "types": "./dist/collab/admission.d.ts",
+      "import": "./dist/collab/admission.js"
+    },
+    "./hosts": {
+      "types": "./dist/hosts/index.d.ts",
+      "import": "./dist/hosts/index.js"
+    },
+    "./doctor": {
+      "types": "./dist/app/doctor.d.ts",
+      "import": "./dist/app/doctor.js"
+    },
+    "./init": {
+      "types": "./dist/app/init.d.ts",
+      "import": "./dist/app/init.js"
+    },
+    "./collaboration": {
+      "types": "./dist/app/collaboration.d.ts",
+      "import": "./dist/app/collaboration.js"
+    },
+    "./install": {
+      "types": "./dist/install/index.d.ts",
+      "import": "./dist/install/index.js"
+    },
+    "./continuity": {
+      "types": "./dist/continuity/index.d.ts",
+      "import": "./dist/continuity/index.js"
+    },
+    "./code": {
+      "types": "./dist/code/index.d.ts",
+      "import": "./dist/code/index.js"
+    },
+    "./knowledge": {
+      "types": "./dist/knowledge/index.d.ts",
+      "import": "./dist/knowledge/index.js"
+    },
+    "./schemas": {
+      "types": "./dist/schemas/index.d.ts",
+      "import": "./dist/schemas/index.js"
+    },
+    "./workspace": {
+      "types": "./dist/workspace/index.d.ts",
+      "import": "./dist/workspace/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "assets",
+    "skills",
+    "README.md",
+    "THIRD_PARTY_NOTICES.md"
+  ],
+  "scripts": {
+    "build:scripts": "tsc -p tsconfig.scripts.json",
+    "build": "tsc -p tsconfig.scripts.json && node .build/scripts/scripts/clean-build.js && tsc -p tsconfig.build.json && node .build/scripts/scripts/build-assets.js",
+    "typecheck": "tsc -p tsconfig.build.json --noEmit && tsc -p tsconfig.test.json --noEmit && tsc -p tsconfig.scripts.json --noEmit",
+    "pretest": "pnpm build && tsc -p tsconfig.test.json",
+    "test": "node .build/test/scripts/run-tests.js",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "source:check": "pnpm build:scripts && node .build/scripts/scripts/check-source-policy.js",
+    "package:check": "pnpm build && node .build/scripts/scripts/verify-package.js",
+    "check": "pnpm source:check && pnpm typecheck && pnpm format:check && pnpm test && pnpm package:check",
+    "prepare": "npm run build",
+    "prepack": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "24.19.1",
+    "esbuild": "^0.28.2",
+    "prettier": "3.9.9",
+    "typescript": "7.0.2"
+  },
+  "dependencies": {
+    "@clack/prompts": "1.8.1",
+    "zod": "4.6.6"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/phyzess/pappra.git"
+  },
+  "homepage": "https://github.com/phyzess/pappra",
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild"
+    ]
+  }
+}