structured-context 0.9.3 → 0.11.0

package/dist/space-context.d.ts

@@ -0,0 +1,24 @@
+import { type Config } from './config';
+import type { SpaceContext } from './types';
+/** Thrown by createSpaceContext when no space matches the given name. */
+export declare class SpaceNotFoundError extends Error {
+    readonly spaceName: string;
+    constructor(spaceName: string);
+}
+export interface CreateSpaceContextOptions {
+    /**
+     * Directory to anchor relative plugin-config paths against. Defaults to the source
+     * directory recorded by loadConfig (space.sourceDir). Required for a hand-assembled
+     * Config, which has no source file — pass e.g. process.cwd(), or the directory the
+     * paths are relative to.
+     */
+    configDir?: string;
+}
+/**
+ * Build a SpaceContext for a named space from an already-loaded config.
+ *
+ * Library-safe: throws {@link SpaceNotFoundError} on an unknown space rather than
+ * writing to the console or exiting the process. CLI callers that want the
+ * exit-on-error behaviour should wrap this (see buildSpaceContext in index.ts).
+ */
+export declare function createSpaceContext(spaceName: string, config: Config, options?: CreateSpaceContextOptions): SpaceContext;

package/dist/space-context.js

@@ -0,0 +1,41 @@
+import { resolveSchema } from './config';
+import { loadSchema } from './schema/schema';
+/** Thrown by createSpaceContext when no space matches the given name. */
+export class SpaceNotFoundError extends Error {
+    spaceName;
+    constructor(spaceName) {
+        super(`Unknown space "${spaceName}"`);
+        this.spaceName = spaceName;
+        this.name = 'SpaceNotFoundError';
+    }
+}
+/**
+ * Build a SpaceContext for a named space from an already-loaded config.
+ *
+ * Library-safe: throws {@link SpaceNotFoundError} on an unknown space rather than
+ * writing to the console or exiting the process. CLI callers that want the
+ * exit-on-error behaviour should wrap this (see buildSpaceContext in index.ts).
+ */
+export function createSpaceContext(spaceName, config, options = {}) {
+    const space = config.spaces.find((s) => s.name === spaceName);
+    if (!space) {
+        throw new SpaceNotFoundError(spaceName);
+    }
+    const configDir = options.configDir ?? space.sourceDir;
+    if (configDir === undefined) {
+        throw new Error(`Cannot resolve a config directory for space "${spaceName}": its Config was not loaded from a ` +
+            `file. Pass options.configDir (e.g. process.cwd()) to anchor relative plugin paths, or load ` +
+            `the config with loadConfig().`);
+    }
+    const resolvedSchemaPath = resolveSchema(config, space);
+    const { schema, schemaRefRegistry, schemaValidator } = loadSchema(resolvedSchemaPath);
+    return {
+        space,
+        config,
+        resolvedSchemaPath,
+        schema,
+        schemaRefRegistry,
+        schemaValidator,
+        configDir,
+    };
+}

package/dist/types.d.ts

@@ -56,6 +56,42 @@ export type UnresolvedRef = {
     /** Human-readable message matching validate-graph output format. */
     message: string;
 };
+/**
+ * Shared fields for all content link variants.
+ */
+type ContentLinkBase = {
+    /** Display text of the link (text content for markdown links, inner text or target for wikilinks). */
+    text: string;
+    /** Raw link target: URL for markdown links, wikilink path (without [[ ]]) for wikilinks. */
+    target: string;
+    /** Whether the link navigates to a resource or transcludes/embeds it. */
+    action: 'link' | 'embed';
+    /** Anchor fragment (heading or block ref, e.g. 'heading-title' or '^blockid') if present. */
+    anchor?: string;
+};
+/**
+ * A link extracted from node content at parse time, before location classification.
+ * Populated by plugins that support content link extraction (e.g. the markdown plugin).
+ */
+export type ContentLink = ContentLinkBase & {
+    /** Link syntax — used during resolution to determine how to classify the target. */
+    linkSyntax: 'wikilink' | 'markdown';
+};
+/**
+ * A fully classified link from node content, after location resolution.
+ * Present on SpaceNode after graph resolution.
+ */
+export type ResolvedContentLink = ContentLinkBase & {
+    /**
+     * Resolved location classification:
+     * - 'node'     — wikilink resolved to a known space node
+     * - 'internal' — wikilink or relative path, in the source system but not a space node
+     * - 'external' — http/https URL
+     * - 'system'   — file:// URL
+     * - 'protocol' — other scheme (e.g. obsidian://)
+     */
+    location: 'node' | 'internal' | 'external' | 'system' | 'protocol';
+};
 /**
  * A node as produced by a parse plugin — raw type from content, no graph resolution applied.
  * Core enriches this into a SpaceNode after parsing.
@@ -71,6 +107,11 @@ export type BaseNode = {
     linkTargets: string[];
     /** Raw type string from content, as written by the user. */
     type: string;
+    /**
+     * Links extracted from content body and non-edge string fields at parse time.
+     * Populated by plugins that support content link extraction; absent if not populated.
+     */
+    contentLinks?: ContentLink[];
 };
 /**
  * A fully resolved node — enriched by core after plugin parsing.
@@ -85,16 +126,21 @@ export type SpaceNode = BaseNode & {
      * Always present, empty if no parents resolved.
      */
     resolvedParents: ResolvedParentRef[];
+    /**
+     * Links from content body and non-edge fields, with location classified after graph resolution.
+     * Always present, empty if the plugin did not populate rawContentLinks.
+     */
+    resolvedLinks: ResolvedContentLink[];
 };
 export type ParseIssue = {
     /** Source identifier of the file or item (filename or heading title). */
     file: string;
     /** error: prevented the file from producing nodes; warning: file was silently excluded. */
     severity: 'error' | 'warning';
-    /** empty: no content; no-type: no type field;
+    /** no-type: no type field;
      *  parse: parse failure (syntax issue or unexpected content);
      *  plugins may choose to provide additional types. */
-    type: 'empty' | 'no-type' | 'parse' | string;
+    type: 'no-type' | 'parse' | string;
     /** Human-readable detail. */
     message?: string;
 };
@@ -155,3 +201,27 @@ export type SpaceContext = {
     /** Directory of the config file that defines this space. Used for resolving relative paths in plugin configs. */
     configDir: string;
 };
+export interface FileValidationResult {
+    file: string;
+    label: string;
+    space: string;
+    /** Errors keyed by composite id (e.g. `schema:/status:enum:active`, `rule:my-rule-id`). */
+    errors: Record<string, {
+        kind: string;
+        message: string;
+    }>;
+    errorCount: number;
+    /** Warnings keyed by composite id. Do not affect exit code or errorCount. */
+    warnings: Record<string, {
+        kind: string;
+        message: string;
+    }>;
+    warningCount: number;
+    inSpace: true;
+}
+export interface FileNotInSpaceResult {
+    file: string;
+    inSpace: false;
+    message: string;
+}
+export type ValidateFileOutput = FileValidationResult | FileNotInSpaceResult;

package/dist/validate.d.ts

@@ -0,0 +1,59 @@
+import type { ErrorObject } from 'ajv';
+import type { Config } from './config';
+import { extractEntityInfo } from './schema/schema';
+import type { GraphViolation, ParseIssue, ReadSpaceResult, RuleViolation, SchemaWithMetadata, SpaceContext, SpaceNode, ValidateFileOutput } from './types';
+export interface FormattedError {
+    message: string;
+    dedupeKey: string;
+}
+export interface ValidationResult {
+    validCount: number;
+    nodeErrorCount: number;
+    nodeErrors: Array<{
+        file: string;
+        errors: ErrorObject[];
+        nodeData: Record<string, unknown>;
+    }>;
+    refErrors: Array<{
+        file: string;
+        parent: string;
+        error: string;
+    }>;
+    duplicateErrors: Array<{
+        title: string;
+        files: string[];
+    }>;
+    ruleViolations: RuleViolation[];
+    hierarchyViolations: GraphViolation[];
+    orphans: SpaceNode[];
+    parseIssues: ParseIssue[];
+    /** Content links that could not be resolved to a space node. Warning only — not counted in errors. */
+    unresolvedContentLinks: Array<{
+        file: string;
+        target: string;
+    }>;
+}
+/**
+ * Format AJV errors for better readability.
+ * Groups related errors and extracts helpful context like allowed values.
+ */
+export declare function formatErrors(errors: ErrorObject[], schema: SchemaWithMetadata, schemaRefRegistry: Parameters<typeof extractEntityInfo>[1], nodeData: Record<string, unknown>): FormattedError[];
+/**
+ * Run full validation on a space and return a structured result.
+ * Does not output to console or call process.exit.
+ */
+export declare function validateSpace(context: SpaceContext, options?: {
+    readResult?: ReadSpaceResult;
+}): Promise<ValidationResult>;
+/**
+ * Validate a single file within its space.
+ *
+ * Reads the full space (required for graph correctness) but filters all reported
+ * errors to only those attributable to the target file.
+ *
+ * Returns a result object — does not output to console or call process.exit.
+ * If the file is not in any configured space, returns a result with `inSpace: false`.
+ */
+export declare function validateFile(filePath: string, config: Config, options?: {
+    configDir?: string;
+}): Promise<ValidateFileOutput>;

package/dist/validate.js

@@ -0,0 +1,316 @@
+import { isAbsolute, relative, resolve } from 'node:path';
+import { readSpace } from './read/read-space';
+import { extractEntityInfo } from './schema/schema';
+import { validateGraph } from './schema/validate-graph';
+import { validateRules } from './schema/validate-rules';
+import { createSpaceContext } from './space-context';
+import { buildSpaceGraph } from './space-graph';
+/**
+ * Format AJV errors for better readability.
+ * Groups related errors and extracts helpful context like allowed values.
+ */
+export function formatErrors(errors, schema, schemaRefRegistry, nodeData) {
+    const formatted = [];
+    const seen = new Set();
+    // Group errors by instancePath
+    const byPath = new Map();
+    for (const err of errors) {
+        const path = err.instancePath || 'root';
+        if (!byPath.has(path)) {
+            byPath.set(path, []);
+        }
+        byPath.get(path).push(err);
+    }
+    for (const [path, pathErrors] of byPath) {
+        // Check if this is a oneOf failure at root - extract valid types from schema
+        const isRootOneOf = path === 'root' || path === '/type';
+        let hasOneOfContext = false;
+        if (isRootOneOf && pathErrors.length > 1) {
+            hasOneOfContext = Array.isArray(schema.oneOf);
+            if (hasOneOfContext) {
+                const entities = extractEntityInfo(schema, schemaRefRegistry);
+                const validTypes = entities.map((e) => e.type).sort();
+                if (validTypes.length > 0) {
+                    const actualValue = nodeData.type;
+                    // Only show type error if the actual type is NOT in the valid types list
+                    if (actualValue !== undefined && !validTypes.includes(String(actualValue))) {
+                        const message = `Invalid type "${actualValue}". Valid types are: ${validTypes.join(', ')}`;
+                        const key = `type:${validTypes.join(',')}`;
+                        if (!seen.has(key)) {
+                            seen.add(key);
+                            formatted.push({ message, dedupeKey: key });
+                        }
+                    }
+                }
+            }
+        }
+        // Handle individual errors
+        for (const err of pathErrors) {
+            // Skip individual type const/enum errors when in oneOf context (we handle it above)
+            if (hasOneOfContext &&
+                (err.keyword === 'const' || err.keyword === 'enum') &&
+                (err.instancePath === '' || err.instancePath === '/type')) {
+                continue;
+            }
+            const parts = err.instancePath.split('/').filter(Boolean);
+            const fieldName = parts.length > 0 ? parts[parts.length - 1] : 'root';
+            let message = err.message;
+            let key = `${err.instancePath}:${err.keyword}`;
+            // Enhance const errors
+            if (err.keyword === 'const' && err.params?.allowedValue !== undefined) {
+                const actual = err.data !== undefined ? `"${err.data}"` : 'missing value';
+                const expected = `"${err.params.allowedValue}"`;
+                message = `${fieldName}: expected ${expected}, got ${actual}`;
+                key = `${err.instancePath}:const:${err.params.allowedValue}`;
+            }
+            // Enhance enum errors
+            else if (err.keyword === 'enum' && err.params?.allowedValues && Array.isArray(err.params.allowedValues)) {
+                let actual = err.data !== undefined ? `"${err.data}"` : null;
+                // If err.data is undefined, try to get the value from nodeData using the field name
+                if (actual === null && fieldName !== 'root') {
+                    const actualValue = nodeData[fieldName];
+                    if (actualValue !== undefined) {
+                        actual = `"${actualValue}"`;
+                    }
+                }
+                if (actual === null) {
+                    actual = 'missing value';
+                }
+                const allowed = err.params.allowedValues.map((v) => `"${v}"`).join(', ');
+                message = `${fieldName}: ${actual} is not valid. Allowed: ${allowed}`;
+                key = `${err.instancePath}:enum:${err.params.allowedValues.join(',')}`;
+            }
+            // Generic message with path
+            else {
+                message = `${fieldName}: ${err.message}`;
+            }
+            if (!seen.has(key)) {
+                seen.add(key);
+                formatted.push({ message, dedupeKey: key });
+            }
+        }
+    }
+    return formatted;
+}
+/**
+ * Run full validation on a space and return a structured result.
+ * Does not output to console or call process.exit.
+ */
+export async function validateSpace(context, options = {}) {
+    const { schema, schemaRefRegistry, schemaValidator } = context;
+    const metadata = schema.metadata;
+    const readResult = options.readResult ?? (await readSpace(context));
+    const { nodes, parseIssues } = readResult;
+    // Pre-extract valid types for early type validation
+    const validTypes = Array.isArray(schema.oneOf) ? extractEntityInfo(schema, schemaRefRegistry).map((e) => e.type) : [];
+    const result = {
+        validCount: 0,
+        nodeErrorCount: 0,
+        nodeErrors: [],
+        refErrors: [],
+        duplicateErrors: [],
+        ruleViolations: [],
+        hierarchyViolations: [],
+        orphans: [],
+        parseIssues,
+        unresolvedContentLinks: [],
+    };
+    for (const node of nodes) {
+        // Early type validation - check before full AJV validation to prevent cascading errors
+        const nodeType = node.schemaData.type;
+        if (nodeType !== undefined && validTypes.length > 0 && !validTypes.includes(nodeType)) {
+            result.nodeErrorCount++;
+            result.nodeErrors.push({
+                file: node.label,
+                errors: [
+                    {
+                        instancePath: '/type',
+                        keyword: 'enum',
+                        message: `Invalid type "${nodeType}". Valid types are: ${validTypes.sort().join(', ')}`,
+                        params: { allowedValues: validTypes },
+                        schemaPath: '#/oneOf',
+                        data: nodeType,
+                    },
+                ],
+                nodeData: node.schemaData,
+            });
+            continue;
+        }
+        const valid = schemaValidator(node.schemaData);
+        if (valid) {
+            result.validCount++;
+        }
+        else {
+            result.nodeErrorCount++;
+            result.nodeErrors.push({
+                file: node.label,
+                errors: schemaValidator.errors || [],
+                nodeData: node.schemaData,
+            });
+        }
+    }
+    // Detect duplicate node keys (titles)
+    const titleToFiles = new Map();
+    for (const node of nodes) {
+        const title = node.title;
+        if (!titleToFiles.has(title)) {
+            titleToFiles.set(title, []);
+        }
+        titleToFiles.get(title).push(node.label);
+    }
+    for (const [title, files] of titleToFiles) {
+        if (files.length > 1) {
+            result.duplicateErrors.push({ title, files });
+        }
+    }
+    // Validate all hierarchy constraints (field references and structure)
+    const hierarchyValidation = validateGraph(nodes, metadata, readResult.unresolvedRefs);
+    result.refErrors.push(...hierarchyValidation.refErrors);
+    result.hierarchyViolations = [...hierarchyValidation.violations];
+    // Calculate orphan count (informational, not a validation error)
+    if (metadata.hierarchy) {
+        result.orphans = [...buildSpaceGraph(nodes, metadata.hierarchy.levels).orphans];
+    }
+    // Load and execute rules validation if schema defines rules
+    if (metadata.rules) {
+        result.ruleViolations = await validateRules(nodes, metadata.rules);
+    }
+    // Collect unresolved content links (warnings — not errors)
+    const seen = new Set();
+    for (const node of nodes) {
+        for (const link of node.resolvedLinks) {
+            if (link.location === 'internal') {
+                const key = `${node.label}::${link.target}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    result.unresolvedContentLinks.push({ file: node.label, target: link.target });
+                }
+            }
+        }
+    }
+    return result;
+}
+/** Find which space a file belongs to by checking directory containment. */
+function resolveFileSpace(filePath, config) {
+    const absFile = isAbsolute(filePath) ? filePath : resolve(process.cwd(), filePath);
+    for (const space of config.spaces) {
+        const absSpace = isAbsolute(space.path) ? space.path : resolve(process.cwd(), space.path);
+        // Trailing slash prevents prefix-match false positives (e.g. /foo matching /foobar/)
+        const spaceDir = absSpace.endsWith('/') ? absSpace : `${absSpace}/`;
+        if (absFile.startsWith(spaceDir) || absFile === absSpace) {
+            return { space, label: relative(absSpace, absFile) };
+        }
+    }
+    return null;
+}
+/**
+ * Validate a single file within its space.
+ *
+ * Reads the full space (required for graph correctness) but filters all reported
+ * errors to only those attributable to the target file.
+ *
+ * Returns a result object — does not output to console or call process.exit.
+ * If the file is not in any configured space, returns a result with `inSpace: false`.
+ */
+export async function validateFile(filePath, config, options = {}) {
+    const resolved = resolveFileSpace(filePath, config);
+    if (!resolved) {
+        return {
+            file: filePath,
+            inSpace: false,
+            message: 'File does not belong to any configured space.',
+        };
+    }
+    const { space, label } = resolved;
+    const context = createSpaceContext(space.name, config, { configDir: options.configDir });
+    const { schema, schemaRefRegistry, schemaValidator } = context;
+    const metadata = schema.metadata;
+    const readResult = await readSpace(context);
+    const { nodes } = readResult;
+    // Pre-extract valid types for early type validation
+    const validTypes = Array.isArray(schema.oneOf) ? extractEntityInfo(schema, schemaRefRegistry).map((e) => e.type) : [];
+    const errors = {};
+    // Schema validation errors for this node
+    for (const node of nodes) {
+        if (node.label !== label)
+            continue;
+        // Early type validation - check before full AJV validation to prevent cascading errors
+        const nodeType = node.schemaData.type;
+        if (nodeType !== undefined && validTypes.length > 0 && !validTypes.includes(nodeType)) {
+            errors[`schema:type:${validTypes.join(',')}`] = {
+                kind: 'schema',
+                message: `Invalid type "${nodeType}". Valid types are: ${validTypes.sort().join(', ')}`,
+            };
+            continue;
+        }
+        const valid = schemaValidator(node.schemaData);
+        if (!valid) {
+            const formatted = formatErrors(schemaValidator.errors ?? [], schema, schemaRefRegistry, node.schemaData);
+            for (const { message, dedupeKey } of formatted) {
+                errors[`schema:${dedupeKey}`] = { kind: 'schema', message };
+            }
+        }
+    }
+    // Duplicate key errors — include if this file is one of the duplicates
+    const titleToFiles = new Map();
+    for (const node of nodes) {
+        if (!titleToFiles.has(node.title))
+            titleToFiles.set(node.title, []);
+        titleToFiles.get(node.title).push(node.label);
+    }
+    for (const [title, files] of titleToFiles) {
+        if (files.length > 1 && files.includes(label)) {
+            const others = files.filter((f) => f !== label);
+            errors[`duplicate:${title}`] = {
+                kind: 'duplicate',
+                message: `Duplicate title "${title}" also exists in: ${others.join(', ')}`,
+            };
+        }
+    }
+    // Broken links and hierarchy violations from this file
+    const hierarchyValidation = validateGraph(nodes, metadata, readResult.unresolvedRefs);
+    for (const { file, parent, error } of hierarchyValidation.refErrors) {
+        if (file === label) {
+            errors[`broken-link:${parent}`] = { kind: 'broken-link', message: `${parent} → ${error}` };
+        }
+    }
+    for (const v of hierarchyValidation.violations) {
+        if (v.file === label) {
+            errors[`hierarchy:${v.description}`] = { kind: 'hierarchy', message: v.description };
+        }
+    }
+    // Rule violations for this node
+    if (metadata.rules) {
+        const ruleViolations = await validateRules(nodes, metadata.rules);
+        for (const v of ruleViolations) {
+            if (v.file === label) {
+                errors[`rule:${v.ruleId}`] = { kind: 'rule', message: `[${v.ruleId}] ${v.description}` };
+            }
+        }
+    }
+    // Unresolved content links for this node (warnings — do not affect errorCount)
+    const warnings = {};
+    const targetNode = nodes.find((n) => n.label === label);
+    if (targetNode) {
+        const seen = new Set();
+        for (const link of targetNode.resolvedLinks) {
+            if (link.location === 'internal' && !seen.has(link.target)) {
+                seen.add(link.target);
+                warnings[`content-link:${link.target}`] = {
+                    kind: 'content-link',
+                    message: `Unresolved content link: ${link.target}`,
+                };
+            }
+        }
+    }
+    return {
+        file: isAbsolute(filePath) ? filePath : resolve(process.cwd(), filePath),
+        label,
+        space: space.name,
+        errors,
+        errorCount: Object.keys(errors).length,
+        warnings,
+        warningCount: Object.keys(warnings).length,
+        inSpace: true,
+    };
+}

package/docs/concepts.md

@@ -254,6 +254,29 @@ Each entry is a `ResolvedParentRef` object:
 
 The `source` label lets downstream consumers distinguish edge types without re-inspecting the schema. Validation routes `hierarchy` edges to structural checks (parent-type rules, skip-level detection) and `relationship` edges to field reference checks (type-match, missing-target). Tree rendering and rule evaluation use the full set.
 
+### Content links
+
+**Content links** (`resolvedLinks` on `SpaceNode`) are all links extracted from a node's content at parse time — both from frontmatter non-edge fields and from the body text. They are distinct from graph edges: they are never used to infer structure, but are available to consumers for rendering, auditing, or navigation.
+
+Each entry is a `ResolvedContentLink` object:
+
+| Field | Type | Description |
+|---|---|---|
+| `text` | `string` | Display text of the link |
+| `target` | `string` | Raw link target (URL or wikilink path) |
+| `action` | `'link' \| 'embed'` | Whether the link navigates or transcludes |
+| `anchor` | `string?` | Fragment component (heading or block ref) if present |
+| `location` | `'node' \| 'internal' \| 'external' \| 'system' \| 'protocol'` | Resolved location classification |
+
+**Location classification:**
+- `node` — wikilink resolved to a known space node
+- `internal` — wikilink or relative path to an in-source target that is not a space node
+- `external` — `http://` or `https://` URL
+- `system` — `file://` URL
+- `protocol` — any other scheme (e.g. `obsidian://`)
+
+**Sources:** Both wikilink syntax (`[[Target]]`, `![[Image]]`) and markdown link syntax (`[text](url)`, `![alt](url)`) are extracted. Bare URLs in frontmatter string fields are also captured. Graph edge fields (hierarchy `parent`, relationship fields) are excluded — those are graph edges, not content links.
+
 ### Anchor
 
 An **anchor** is a block anchor (e.g. `^goal1`) appended to a heading in a `typed page`, using Obsidian block anchor syntax. Anchors serve two purposes:

package/docs/config.md

@@ -28,6 +28,8 @@ A space is a named directory or single file registered in the config. Example:
 
 **`includeSpacesFrom`** — import space definitions from other config files. Useful for aggregating spaces from multiple projects into a central config. Duplicate space names are not allowed.
 
+A config must define at least one of `spaces` or `includeSpacesFrom`. When using `includeSpacesFrom` alone, `spaces` can be omitted entirely.
+
 ## Plugins
 
 Use `plugins` to load parse plugins that read spaces from non-markdown sources. The built-in markdown plugin is always available without any declaration. Plugins are tried in order; the first to return a result wins. The `plugins` field is a map of plugin name to plugin config, and can be declared at the top level (applies to all spaces) or per-space (overrides the top level):

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "structured-context",
-  "version": "0.9.3",
-  "description": "Tools for working with Opportunity Solution Tree structures and other product management and strategy frameworks",
+  "version": "0.11.0",
+  "description": "Keep your content clean and your thinking clear with assistive tools for structured knowledge",
   "module": "./dist/index.js",
   "type": "module",
   "license": "MIT",
@@ -18,9 +18,13 @@
   ],
   "exports": {
     ".": "./dist/index.js",
-    "./plugin-api": {
-      "types": "./dist/plugin-api.d.ts",
-      "default": "./dist/plugin-api.js"
+    "./api": {
+      "types": "./dist/api.d.ts",
+      "default": "./dist/api.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "default": "./dist/types.js"
     }
   },
   "scripts": {
@@ -57,8 +61,10 @@
     "ajv": "^8.18.0",
     "chokidar": "^5.0.0",
     "commander": "^14.0.3",
+    "fast-glob": "^3.3.3",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.1",
+    "json5": "^2.2.3",
     "jsonata": "^2.1.0",
     "mdast-util-to-string": "^4.0.0",
     "remark-gfm": "^4.0.1",

package/schemas/_knowledge_wiki.json

@@ -207,7 +207,7 @@
     },
     "note": {
       "type": "object",
-      "description": "Personal notes, journal entries, appointments, experiential records. Your own data about your journey — not sourced from external material.",
+      "description": "Personal notes, journal entries, talk notes, or rough thoughts not drawn from an external URL.",
       "allOf": [{ "$ref": "sctx://_sctx_base#/$defs/baseNodeProps" }],
       "properties": {
         "type": { "const": "note" },

package/dist/integrations/miro/sync.d.ts

@@ -1,8 +0,0 @@
-import type { SpaceContext } from '../../types';
-interface SyncOptions {
-    newFrame?: string;
-    dryRun?: boolean;
-    verbose?: boolean;
-}
-export declare function miroSync(context: SpaceContext, options: SyncOptions): Promise<void>;
-export {};

package/dist/plugin-api.d.ts

@@ -1,12 +0,0 @@
-/**
- * Public API for external structured-context plugins.
- *
- * Import from this module to get the types needed to implement a StructuredContextPlugin:
- *
- *   import type { StructuredContextPlugin, PluginContext, ParseResult } from 'structured-context/plugin-api';
- */
-export type { AnySchemaObject, SchemaObject, ValidateFunction } from 'ajv';
-export type { ParseHook, ParseResult, PluginContext, RenderFormat, RenderHook, RenderOptions, StructuredContextPlugin, TemplateSyncHook, TemplateSyncOptions, } from './plugins/util';
-export type { SharedEmbeddingFields } from './schema/metadata-contract';
-export type { SpaceGraph } from './space-graph';
-export type { BaseNode, EdgeDefinition, HierarchyLevel, ParseIssue, Relationship, SchemaMetadata, SchemaWithMetadata, SpaceContext, SpaceNode, UnresolvedRef, } from './types';

package/dist/plugin-api.js

@@ -1,7 +0,0 @@
-/**
- * Public API for external structured-context plugins.
- *
- * Import from this module to get the types needed to implement a StructuredContextPlugin:
- *
- *   import type { StructuredContextPlugin, PluginContext, ParseResult } from 'structured-context/plugin-api';
- */