@knowledge-medium/agent-cli 0.1.0

package/dist/kernel-types/src/data/orderKey.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Order-key helpers (spec §4.1, §16.12).
+ *
+ * Backed by `fractional-indexing-jittered`'s base62 character set. Two
+ * concurrent clients inserting between the same neighbors will most
+ * likely compute distinct keys (jitter); residual collisions resolve
+ * via the `(order_key, id)` secondary sort the SUBTREE_SQL CTE +
+ * `idx_blocks_parent_order` index both rely on.
+ *
+ * Why base62 + this lib over plain `fractional-indexing`:
+ *   - Jittering reduces collision rate at no measurable cost.
+ *   - Base62 (`0-9A-Za-z`) is alphanumeric, so order-keys can't contain
+ *     the `!` (0x21) separator the path-encoding CTE uses (§11.1).
+ *   - All base62 chars sort lex-greater than `!`, so `<order_key>!hex(id)/`
+ *     gives the right sibling order for prefix-related keys (e.g. `a` vs
+ *     `aa`) — see the v4.25 separator analysis in §11.1 of the spec.
+ *
+ * `null` values mean "no neighbor on this side" — i.e. the new key
+ * goes at the start or end of the list.
+ */
+/** A new key strictly between `lower` and `upper`. Pass `null` for the
+ *  end of the list.
+ *    keyBetween(null, null)  → first key when there are no siblings
+ *    keyBetween(null, 'A0')  → before A0
+ *    keyBetween('A0', null)  → after A0
+ *    keyBetween('A0', 'A1')  → strictly between A0 and A1
+ */
+export declare const keyBetween: (lower: string | null, upper: string | null) => string;
+/** N new keys strictly between `lower` and `upper`. Returned in
+ *  ascending order; safe to insert as a contiguous run of siblings. */
+export declare const keysBetween: (lower: string | null, upper: string | null, n: number) => string[];
+/** First key — for an empty sibling list, or to put a new row at the
+ *  very start. */
+export declare const keyAtStart: (firstExisting?: string | null) => string;
+/** Last key — for an empty sibling list, or to put a new row at the
+ *  very end. */
+export declare const keyAtEnd: (lastExisting?: string | null) => string;
+//# sourceMappingURL=orderKey.d.ts.map

package/dist/kernel-types/src/data/orderKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orderKey.d.ts","sourceRoot":"","sources":["../../../../../../src/data/orderKey.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAOH;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GACrB,OAAO,MAAM,GAAG,IAAI,EACpB,OAAO,MAAM,GAAG,IAAI,KACnB,MAAkD,CAAA;AAErD;uEACuE;AACvE,eAAO,MAAM,WAAW,GACtB,OAAO,MAAM,GAAG,IAAI,EACpB,OAAO,MAAM,GAAG,IAAI,EACpB,GAAG,MAAM,KACR,MAAM,EAAmD,CAAA;AAE5D;kBACkB;AAClB,eAAO,MAAM,UAAU,GAAI,gBAAe,MAAM,GAAG,IAAW,KAAG,MAChC,CAAA;AAEjC;gBACgB;AAChB,eAAO,MAAM,QAAQ,GAAI,eAAc,MAAM,GAAG,IAAW,KAAG,MAC9B,CAAA"}

package/dist/kernel-types/src/data/pluginStateExtensions.d.ts

@@ -0,0 +1,27 @@
+/** Bundling helpers for plugin-owned prefs / ui-state sub-blocks.
+ *
+ *  Each plugin that owns a per-user pref sub-block or a per-device
+ *  ui-state sub-block declares it as a `TypeContribution` and registers
+ *  via one of the helpers below. The helpers pair the `typesFacet`
+ *  registration with an idle-time eager-bootstrap `AppEffect` so the
+ *  sub-block exists before the user navigates to the Preferences /
+ *  ui-state tree — without this, plugin sub-blocks would only appear
+ *  after their hooks run for the first time, making configurable
+ *  options non-discoverable.
+ */
+import type { TypeContribution } from '@/data/api';
+import type { AppExtension } from '@/extensions/facet.js';
+/** Bundle a plugin-prefs `TypeContribution` registration with an
+ *  idle-time eager-bootstrap effect. Spread the returned array into the
+ *  plugin's `AppExtension`:
+ *
+ *      export const myPlugin: AppExtension = [
+ *        ...pluginPrefsExtension(myPrefsType, 'my-plugin'),
+ *        // …other facet contributions…
+ *      ]
+ */
+export declare const pluginPrefsExtension: (type: TypeContribution, source: string) => readonly AppExtension[];
+/** Same as `pluginPrefsExtension`, for sub-blocks under the root
+ *  ui-state subtree (device-local, scoped via ChangeScope.UiState). */
+export declare const pluginUIStateExtension: (type: TypeContribution, source: string) => readonly AppExtension[];
+//# sourceMappingURL=pluginStateExtensions.d.ts.map

package/dist/kernel-types/src/data/pluginStateExtensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pluginStateExtensions.d.ts","sourceRoot":"","sources":["../../../../../../src/data/pluginStateExtensions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAGlD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAsBzD;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,GAC/B,MAAM,gBAAgB,EACtB,QAAQ,MAAM,KACb,SAAS,YAAY,EAGvB,CAAA;AAED;uEACuE;AACvE,eAAO,MAAM,sBAAsB,GACjC,MAAM,gBAAgB,EACtB,QAAQ,MAAM,KACb,SAAS,YAAY,EAGvB,CAAA"}

package/dist/kernel-types/src/data/properties.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Kernel + UI-state property descriptors. Each export is a
+ * `PropertySchema<T>` (data-layer definition with codec + default +
+ * change scope). Per-name editor overrides for the rare property that
+ * needs one live separately under `propertyEditorOverridesFacet`
+ * (Phase 3). See spec §4.1.1 / §5.6 / §6.
+ *
+ * Migration note (1.6): legacy creator helpers (`stringProperty`,
+ * `boolProp`, `objectProperty`, etc.) returned a record-shape
+ * `{name, type, value}` that doubled as schema AND value. The new
+ * shape is flat — `block.set(schema, value)` / `block.get(schema)`
+ * encode/decode through the codec; storage holds the encoded value
+ * directly. Helpers like `aliasProp(['x','y'])` (which embedded a
+ * default value into the descriptor) are gone — the schema's
+ * `defaultValue` is the single source of truth, callers pass values
+ * via `block.set(schema, value)`.
+ */
+import type { Block } from './block';
+import type { BlockData, ChangedRow } from '@/data/api';
+import { aliasesProp } from '@/data/internals/coreProperties';
+import { type PropertySchema } from '@/data/api';
+export declare const showPropertiesProp: PropertySchema<boolean>;
+export declare const isEditingProp: PropertySchema<boolean>;
+export declare const topLevelBlockIdProp: PropertySchema<string | undefined>;
+export declare const focusedBlockIdProp: PropertySchema<string | undefined>;
+export declare const focusedVisualTargetKeyProp: PropertySchema<string | undefined>;
+export declare const activePanelIdProp: PropertySchema<string | undefined>;
+export declare const scrollTopProp: PropertySchema<number | undefined>;
+/** Editor-selection state for the active block. Object-typed; the
+ *  `unsafeIdentity` codec is appropriate because the shape is engine-
+ *  controlled and not exposed for plugin extension. The optional
+ *  `line` / `x` / `y` fields are placement hints used by CodeMirror's
+ *  cursor-restoration helpers — start/end are the linear offsets,
+ *  x/y are pixel coordinates for visual restoration after a wrap. */
+export interface EditorSelectionState {
+    blockId: string;
+    start?: number;
+    end?: number;
+    line?: 'first' | 'last';
+    x?: number;
+    y?: number;
+}
+export declare const editorSelection: PropertySchema<EditorSelectionState | undefined>;
+export declare const editorFocusRequestProp: PropertySchema<number>;
+export interface BlockSelectionState {
+    selectedBlockIds: string[];
+    anchorBlockId: string | null;
+}
+export declare const selectionStateProp: PropertySchema<BlockSelectionState>;
+export declare const isCollapsedProp: PropertySchema<boolean>;
+export declare const typesProp: PropertySchema<readonly string[]>;
+export declare const rendererProp: PropertySchema<string | undefined>;
+export declare const rendererNameProp: PropertySchema<string | undefined>;
+export declare const createdAtProp: PropertySchema<number | undefined>;
+export declare const sourceBlockIdProp: PropertySchema<string | undefined>;
+/** Human-readable extension name. Kept on the block instead of inside
+ *  executable extension code so disabled extensions can still be
+ *  described in settings without compiling them. */
+export declare const extensionNameProp: PropertySchema<string>;
+/** Optional extension description displayed in the settings surface. */
+export declare const extensionDescriptionProp: PropertySchema<string>;
+/** User-supplied property name on a `'property-schema'` block. */
+export declare const propertyNameProp: PropertySchema<string>;
+/** Preset id on a `'property-schema'` block — matches a registered
+ *  `ValuePreset.id` (and the codec's `type` for codecs built by that
+ *  preset). */
+export declare const presetIdProp: PropertySchema<string>;
+/** Preset-specific config JSON. Stored as opaque JSON via the
+ *  `unsafeIdentity` codec; validation happens in the preset's
+ *  `configCodec.decode` at registration time. */
+export declare const presetConfigProp: PropertySchema<Record<string, unknown>>;
+/** Human-readable label on a `'block-type'` block. Shown in the type
+ *  picker and as the section header in the property panel. */
+export declare const blockTypeLabelProp: PropertySchema<string>;
+/** Optional free-form description on a `'block-type'` block. */
+export declare const blockTypeDescriptionProp: PropertySchema<string>;
+/** RefList over `'property-schema'` blocks. UserTypesService resolves
+ *  each ref to the merged property-schema map (via
+ *  `UserSchemasService.getSchemaForBlockId`) to build the lifted
+ *  property list on the resulting TypeContribution. */
+export declare const blockTypePropertiesProp: PropertySchema<readonly string[]>;
+/** Re-export of the canonical alias schema (defined under
+ *  `@/data/internals/coreProperties.ts` so the kernel parseReferences
+ *  processor can reference it without circling back through this
+ *  module). Kept here so call-site migrations can import every
+ *  descriptor from a single path. */
+export { aliasesProp };
+export declare const getBlockTypes: (data: Pick<BlockData, "properties">) => readonly string[];
+export declare const hasBlockType: (data: Pick<BlockData, "properties">, typeId: string) => boolean;
+/** Type-membership delta helpers for same-tx processors that watch the
+ *  `properties` field. `row.before` is null on insert; `row.after` is
+ *  null on hard-delete — both are null-safe here, returning the
+ *  appropriate one-sided diff. Order in the returned array matches
+ *  `typesProp.codec.decode` order on whichever side is non-null. */
+export declare const addedTypes: (row: ChangedRow) => readonly string[];
+export declare const removedTypes: (row: ChangedRow) => readonly string[];
+/** Raw membership writer for BlockData construction paths that do not
+ *  have a Repo/Tx available. Does not run setup or materialise
+ *  addType initial values. */
+export declare const addBlockTypeToProperties: (properties: Record<string, unknown>, typeId: string) => Record<string, unknown>;
+/** Set the editing flag on the UI-state block. Refuses to enter edit
+ *  mode in a read-only repo (workspace viewer) — the wrappers also
+ *  short-circuit, but this gate keeps any new caller honest. */
+export declare const setIsEditing: (uiStateBlock: Block, editing: boolean) => void;
+/** Atomically move focus to `blockId` and set the edit flag in one tx.
+ *
+ *  `useInEditMode(blockId)` is `focusedBlockId === blockId && isEditing`,
+ *  so the pair behaves as one state — writing focus alone makes the
+ *  newly-focused block inherit the previous holder's editing flag, and
+ *  `vimNormalModeActivation` declines to put a block into NORMAL_MODE
+ *  while its `inEditMode` is true. This is the single primitive for
+ *  changing what block has focus: callers pass `{edit: true}` when they
+ *  want the new block in edit mode (cm navigation, vim's `o`, etc.)
+ *  and omit it (default `false`) to land on the block out of edit mode.
+ *
+ *  Returns the tx-commit promise so callers that need to observe
+ *  focus-derived state next can `await` instead of racing propagation. */
+export declare const focusBlock: (uiStateBlock: Block, blockId: string, options?: {
+    edit?: boolean;
+}) => Promise<void>;
+export declare const focusVisualTarget: (uiStateBlock: Block, blockId: string, visualTargetKey: string, options?: {
+    edit?: boolean;
+}) => Promise<void>;
+export declare const requestEditorFocus: (uiStateBlock: Block) => void;
+export type { PropertySchema };
+/** Every kernel-owned `PropertySchema` in one array. Consumed by
+ *  `kernelDataExtension` to register them with `propertySchemasFacet`
+ *  so non-React surfaces (the property panel's schema lookup, future
+ *  CLI / server-side audit, plugin authors inspecting the registry)
+ *  see the kernel descriptors uniformly.
+ *
+ *  Heterogeneous `PropertySchema<T>` shapes flatten through
+ *  `PropertySchema<unknown>` for storage in the array — the precise
+ *  per-schema types stay at the export sites and reach typed callers
+ *  via the schema reference (`block.set(typesProp, ...)` etc.). */
+export declare const KERNEL_PROPERTY_SCHEMAS: ReadonlyArray<PropertySchema<unknown>>;
+//# sourceMappingURL=properties.d.ts.map

package/dist/kernel-types/src/data/properties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"properties.d.ts","sourceRoot":"","sources":["../../../../../../src/data/properties.ts"],"names":[],"mappings":"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"}

package/dist/kernel-types/src/data/propertiesPage.d.ts

@@ -0,0 +1,8 @@
+/** Properties-page bootstrap. Thin wrapper around `getOrCreateKernelPage`
+ *  with Properties-specific args. Each workspace has one Properties page;
+ *  user-defined property-schema blocks live as its children. */
+import type { Block } from '@/data/block';
+import type { Repo } from '@/data/repo';
+export declare const propertiesPageBlockId: (workspaceId: string) => string;
+export declare const getOrCreatePropertiesPage: (repo: Repo, workspaceId: string) => Promise<Block>;
+//# sourceMappingURL=propertiesPage.d.ts.map

package/dist/kernel-types/src/data/propertiesPage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"propertiesPage.d.ts","sourceRoot":"","sources":["../../../../../../src/data/propertiesPage.ts"],"names":[],"mappings":"AAAA;;gEAEgE;AAEhE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAOvC,eAAO,MAAM,qBAAqB,GAAI,aAAa,MAAM,KAAG,MACR,CAAA;AAEpD,eAAO,MAAM,yBAAyB,GAAI,MAAM,IAAI,EAAE,aAAa,MAAM,KAAG,OAAO,CAAC,KAAK,CAKrF,CAAA"}