@ponraaj/dimple-sdk 0.0.0-alpha.1

package/dist/config.d.ts

@@ -0,0 +1,13 @@
+import { Effect, Layer } from "effect";
+import { Service as ConfigService } from "./internal/config/index.js";
+import type { DimpleConfig as DimpleConfigType } from "./internal/config/index.js";
+import { ConfigError } from "./errors.ts";
+/**
+ * The SDK's config input: a `dimple.jsonc` FILE PATH or an inline object
+ * (typed as `DimpleConfig` — the SDK validates it and fills defaults).
+ */
+export type ConfigInput = string | Partial<DimpleConfigType> | DimpleConfigType;
+/** Resolve either input form to the validated config snapshot. */
+export declare const resolveConfigInput: (input: ConfigInput) => Effect.Effect<DimpleConfigType, ConfigError, never>;
+/** A `ConfigService` layer from the SDK's config input (path or object). */
+export declare const configLayerFromInput: (input: ConfigInput) => Layer.Layer<ConfigService, ConfigError, never>;

package/dist/dimple.d.ts

@@ -0,0 +1,101 @@
+import { ManagedRuntime } from "effect";
+import type { QueryProfile } from "./internal/retriever/index.js";
+import type { CoreInterface } from "./internal/core/index.js";
+import type { CodeExtractor } from "./internal/extractor/index.js";
+import type { CodeParser } from "./internal/parser/index.js";
+import type { AddEdgeInput, AugmentedMemory, ExplainResult, GraphCandidatesResult, GraphCoverage, MemoryUnit, TopicHealth, WriteMemoryInput } from "./internal/store/index.js";
+import { type DimpleError } from "./errors.ts";
+/** Options for a `query` call — mirrors the hybrid retriever's options. */
+export interface QueryOptions {
+    readonly namespace?: string;
+    readonly limit?: number;
+    readonly k?: number;
+    /** Fusion profile, or the mode-string shorthand
+     * (`"hybrid" | "semantic" | "keyword"`). */
+    readonly profile?: QueryProfile | "hybrid" | "semantic" | "keyword";
+    readonly topics?: {
+        readonly topicKeys?: ReadonlyArray<string>;
+    };
+}
+/** Options for a `write` call. */
+export interface WriteOptions {
+    /** Embed the content with the default model and route it into the topic
+     * tree (default true). Pass `false` when embeddings are managed
+     * externally (backfill paths). */
+    readonly embed?: boolean;
+}
+/** Options for an `index` call — parse + extract real code into memories. */
+export interface IndexOptions {
+    /** Directories (walked recursively) and/or files to index. */
+    readonly paths: readonly string[];
+    /** Logical-key prefix for every unit (default `"code-"`). Keys are
+     * `<prefix><relative-path>` (file unit) and
+     * `<prefix><relative-path>#<chunk-id>` (extracted unit) — stable across
+     * runs and cwds, so re-indexing the same tree SKIPS existing units. */
+    readonly keyPrefix?: string;
+    readonly namespace?: string;
+    /** Embed + topic-route every unit (default true). */
+    readonly embed?: boolean;
+    /** Cap for the whole-file memory content (default 64 KiB). */
+    readonly maxFileBytes?: number;
+    /** Cap for each extracted chunk's content (default 8 KiB). */
+    readonly maxChunkBytes?: number;
+    /** Extensions to index (default: the TypeScript/JavaScript family). */
+    readonly extensions?: readonly string[];
+}
+/** Result of an `index` call — per-file failures never abort the run. */
+export interface IndexResult {
+    /** Files parsed (supported extension). */
+    readonly files: number;
+    /** Memory units written (file unit + extracted chunks). */
+    readonly indexed: number;
+    /** Units skipped as already-indexed (duplicate logical keys). */
+    readonly skipped: number;
+    /** Files skipped because the extension is not indexable. */
+    readonly unsupported: number;
+    /** Files that could not be walked/read/parsed/extracted/written. */
+    readonly failed: readonly {
+        readonly filePath: string;
+        readonly message: string;
+    }[];
+}
+/**
+ * The promise-based SDK facade — the ONLY surface app code touches.
+ * Every method runs the underlying Effect at the boundary, remaps errors
+ * onto the closed `DimpleError` hierarchy, and never leaks Effect types.
+ */
+export interface Dimple {
+    readonly write: (input: WriteMemoryInput, options?: WriteOptions) => Promise<MemoryUnit>;
+    readonly get: (id: string) => Promise<MemoryUnit>;
+    readonly query: (text: string, options?: QueryOptions) => Promise<AugmentedMemory[]>;
+    readonly forget: (id: string) => Promise<void>;
+    /** Parse + extract a directory/files with tree-sitter and store the
+     * result as memories: one whole-file unit (with its import graph in
+     * metadata) + one unit per extracted definition (function/class/method/
+     * interface/type/enum/variable with JSDoc + line range). Re-indexing
+     * the same tree is idempotent (duplicate keys are skipped). */
+    readonly index: (options: IndexOptions) => Promise<IndexResult>;
+    /** Attach an externally-computed embedding (the `{ embed: false }`
+     * workflow's completion path): the memory becomes semantically
+     * retrievable and is routed into the model's topic tree. */
+    readonly updateEmbedding: (id: string, embedding: readonly number[], modelKey?: string) => Promise<void>;
+    /** Embed text with the default model (the SDK's own pipeline). */
+    readonly embed: (text: string) => Promise<number[]>;
+    readonly dream: (modelKey: string) => Promise<void>;
+    readonly repair: (modelKey: string) => Promise<void>;
+    readonly explain: (input: {
+        readonly kind: "memory" | "topic" | "concept";
+        readonly id: string;
+    }) => Promise<ExplainResult>;
+    readonly health: (modelKey: string) => Promise<TopicHealth>;
+    readonly graph: {
+        readonly addEdge: (input: AddEdgeInput) => Promise<unknown>;
+        readonly candidates: () => Promise<GraphCandidatesResult>;
+        readonly coverage: (modelKey: string) => Promise<GraphCoverage>;
+    };
+    /** Stops the worker, closes the sinks and the store — idempotent. */
+    readonly dispose: () => Promise<void>;
+}
+/** Build the promise facade over the booted core + runtime. */
+export declare const makeFacade: <ER>(runtime: ManagedRuntime.ManagedRuntime<never, ER>, core: CoreInterface, parser: CodeParser["Service"], extractor: CodeExtractor["Service"], dispose: () => Promise<void>) => Dimple;
+export type { DimpleError };

package/dist/errors.d.ts

@@ -0,0 +1,63 @@
+import { Schema } from "effect";
+declare const ConfigError_base: Schema.Class<ConfigError, Schema.TaggedStruct<"Sdk.ConfigError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The SDK's CLOSED error hierarchy — the only errors consumers ever see.
+ * Effect's `Cause`/`FiberFailure` never leak past the facade: every
+ * underlying error is remapped at the boundary (see `remapError`).
+ */
+export declare class ConfigError extends ConfigError_base {
+}
+declare const NotFoundError_base: Schema.Class<NotFoundError, Schema.TaggedStruct<"Sdk.NotFound", {
+    readonly id: Schema.optional<Schema.String>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The requested memory (or topic/edge) does not exist. */
+export declare class NotFoundError extends NotFoundError_base {
+}
+declare const DuplicateKeyError_base: Schema.Class<DuplicateKeyError, Schema.TaggedStruct<"Sdk.DuplicateKey", {
+    readonly logicalKey: Schema.String;
+    readonly namespace: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** An active memory with the same logical key already exists. */
+export declare class DuplicateKeyError extends DuplicateKeyError_base {
+}
+declare const LLMNotConfiguredError_base: Schema.Class<LLMNotConfiguredError, Schema.TaggedStruct<"Sdk.LLMNotConfigured", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** `memory.dream` was requested without an LLM configured. */
+export declare class LLMNotConfiguredError extends LLMNotConfiguredError_base {
+}
+declare const JobFailedError_base: Schema.Class<JobFailedError, Schema.TaggedStruct<"Sdk.JobFailed", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A durable job failed on the enqueue/wait path. */
+export declare class JobFailedError extends JobFailedError_base {
+}
+declare const DuplicateEdgeError_base: Schema.Class<DuplicateEdgeError, Schema.TaggedStruct<"Sdk.DuplicateEdge", {
+    readonly fromMemoryId: Schema.String;
+    readonly toMemoryId: Schema.String;
+    readonly edgeKind: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A duplicate memory↔memory edge (same from/to/kind already exists). */
+export declare class DuplicateEdgeError extends DuplicateEdgeError_base {
+}
+declare const StoreFailure_base: Schema.Class<StoreFailure, Schema.TaggedStruct<"Sdk.StoreFailure", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Anything else — the typed fallback that keeps the union closed. */
+export declare class StoreFailure extends StoreFailure_base {
+}
+declare const InputError_base: Schema.Class<InputError, Schema.TaggedStruct<"Sdk.InputError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Invalid SDK call input (bad `limit`, `k`, profile shape, …). */
+export declare class InputError extends InputError_base {
+}
+export type DimpleError = ConfigError | NotFoundError | DuplicateKeyError | DuplicateEdgeError | LLMNotConfiguredError | JobFailedError | StoreFailure | InputError;
+/** Map an underlying failure onto the closed SDK hierarchy. */
+export declare const remapError: (error: unknown) => DimpleError;
+export {};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { makeDimple, type MakeDimpleOptions } from "./make.ts";
+export { type ConfigInput } from "./config.ts";
+export { type Dimple, type QueryOptions, type IndexOptions, type IndexResult } from "./dimple.ts";
+export { ConfigError, NotFoundError, DuplicateKeyError, DuplicateEdgeError, LLMNotConfiguredError, JobFailedError, StoreFailure, InputError, remapError, type DimpleError, } from "./errors.ts";