@unpolarize/knowledge-planning 0.1.0 → 0.2.0

package/src/store/store.ts

@@ -1,231 +0,0 @@
-import { readFileSync, writeFileSync, readdirSync, existsSync, mkdirSync, appendFileSync } from 'node:fs';
-import { join, dirname, relative } from 'node:path';
-import {
-  SCHEMA_BY_TYPE,
-  EdgeSchema,
-  ns,
-  type Edge,
-  type ObjectType,
-  type PlanningObject,
-} from '../schema/entities.ts';
-import { parseMarkdown, serializeMarkdown } from '../schema/frontmatter.ts';
-import { DEFAULT_CONFIG, type Config } from '../types.ts';
-
-/** A loaded markdown object: validated `object` + raw `data`/`body` for round-trip writes. */
-export interface StoreDoc {
-  id: string;
-  type: ObjectType;
-  path: string; // absolute
-  relpath: string; // relative to store root
-  object: PlanningObject;
-  data: Record<string, unknown>;
-  body: string;
-}
-
-const IGNORE_DIRS = new Set(['node_modules', '.git', '.index', 'src', 'test', 'dist', '.vscode']);
-const CONTAINER_TYPES = new Set<ObjectType>(['project']);
-
-/**
- * Markdown SSOT reader/writer. The directory tree IS the index: every `*.md` with
- * valid `id`+`type` frontmatter is an object, keyed by its `id`. Writes preserve
- * body text and strip empty frontmatter. Edges come from both `edges.jsonl` and
- * object frontmatter (the union is rebuildable, so a clobber is recoverable).
- */
-export class Store {
-  readonly root: string;
-  private docs: Map<string, StoreDoc> | null = null;
-  private warnings: string[] = [];
-
-  constructor(root: string) {
-    this.root = root;
-  }
-
-  get configPath(): string {
-    return join(this.root, 'config.json');
-  }
-
-  get edgesPath(): string {
-    return join(this.root, 'edges.jsonl');
-  }
-
-  config(): Config {
-    if (!existsSync(this.configPath)) return { ...DEFAULT_CONFIG };
-    try {
-      return { ...DEFAULT_CONFIG, ...JSON.parse(readFileSync(this.configPath, 'utf8')) };
-    } catch {
-      return { ...DEFAULT_CONFIG };
-    }
-  }
-
-  /** Force a re-scan on next access. */
-  invalidate(): void {
-    this.docs = null;
-  }
-
-  private ensureLoaded(): Map<string, StoreDoc> {
-    if (this.docs) return this.docs;
-    const docs = new Map<string, StoreDoc>();
-    this.warnings = [];
-    for (const abs of walkMarkdown(this.root)) {
-      let raw: string;
-      try {
-        raw = readFileSync(abs, 'utf8');
-      } catch {
-        continue;
-      }
-      const { data, body } = parseMarkdown(raw);
-      const type = data.type as ObjectType | undefined;
-      const id = data.id as string | undefined;
-      if (!type || !id || !(type in SCHEMA_BY_TYPE)) continue;
-      const schema = SCHEMA_BY_TYPE[type];
-      const res = schema.safeParse(data);
-      if (!res.success) {
-        this.warnings.push(`${relative(this.root, abs)}: ${res.error.issues[0]?.message ?? 'invalid'}`);
-        continue;
-      }
-      docs.set(id, {
-        id,
-        type,
-        path: abs,
-        relpath: relative(this.root, abs),
-        object: res.data as PlanningObject,
-        data,
-        body,
-      });
-    }
-    this.docs = docs;
-    return docs;
-  }
-
-  getWarnings(): string[] {
-    this.ensureLoaded();
-    return this.warnings;
-  }
-
-  all(): StoreDoc[] {
-    return [...this.ensureLoaded().values()];
-  }
-
-  get(id: string): StoreDoc | undefined {
-    return this.ensureLoaded().get(id);
-  }
-
-  byType(type: ObjectType): StoreDoc[] {
-    return this.all().filter((d) => d.type === type);
-  }
-
-  /** Default on-disk path for a new object id. Projects are folders (`<id>/index.md`). */
-  pathForId(id: string, type: ObjectType): string {
-    if (CONTAINER_TYPES.has(type)) return join(this.root, id, 'index.md');
-    return join(this.root, `${id}.md`);
-  }
-
-  /**
-   * Create or overwrite an object. Frontmatter is validated; body defaults to the
-   * existing body when omitted for an existing object.
-   */
-  write(input: Record<string, unknown> & { id: string; type: ObjectType }, body?: string): StoreDoc {
-    const { id, type } = input;
-    if (!(type in SCHEMA_BY_TYPE)) throw new Error(`unknown type: ${type}`);
-    const existing = this.get(id);
-    const data: Record<string, unknown> = { schema: ns(type), ...input };
-    const schema = SCHEMA_BY_TYPE[type];
-    const parsed = schema.parse(data); // throws on invalid
-    const path = existing?.path ?? this.pathForId(id, type);
-    const finalBody = body ?? existing?.body ?? '';
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, serializeMarkdown(data, finalBody), 'utf8');
-    const doc: StoreDoc = {
-      id,
-      type,
-      path,
-      relpath: relative(this.root, path),
-      object: parsed as PlanningObject,
-      data,
-      body: finalBody,
-    };
-    this.ensureLoaded().set(id, doc);
-    return doc;
-  }
-
-  /** Load an object, mutate its frontmatter via `mutator`, and write it back. */
-  patch(id: string, mutator: (data: Record<string, unknown>) => void): StoreDoc {
-    const existing = this.get(id);
-    if (!existing) throw new Error(`object not found: ${id}`);
-    const data = { ...existing.data };
-    mutator(data);
-    return this.write(data as { id: string; type: ObjectType }, existing.body);
-  }
-
-  // --- Edges ---------------------------------------------------------------
-
-  appendEdge(edge: Edge): void {
-    const e = EdgeSchema.parse(edge);
-    appendFileSync(this.edgesPath, JSON.stringify(e) + '\n', 'utf8');
-  }
-
-  /** Explicit edges from edges.jsonl (append-only log). */
-  fileEdges(): Edge[] {
-    if (!existsSync(this.edgesPath)) return [];
-    const out: Edge[] = [];
-    for (const line of readFileSync(this.edgesPath, 'utf8').split('\n')) {
-      const t = line.trim();
-      if (!t) continue;
-      try {
-        out.push(EdgeSchema.parse(JSON.parse(t)));
-      } catch {
-        /* skip malformed line */
-      }
-    }
-    return out;
-  }
-
-  /** Edges derived from object frontmatter (the rebuildable source of truth). */
-  frontmatterEdges(): Edge[] {
-    const edges: Edge[] = [];
-    for (const d of this.all()) {
-      const o = d.object;
-      for (const ref of o.blocked_by ?? [])
-        edges.push({ kind: 'blocked_by', from: o.id, to: ref.path, reason: ref.reason, status: ref.status });
-      for (const c of o.cites ?? []) edges.push({ kind: 'cites', from: o.id, to: c });
-      for (const dep of o.depends_on ?? []) edges.push({ kind: 'depends_on', from: o.id, to: dep });
-      for (const r of o.related ?? []) edges.push({ kind: 'related', from: o.id, to: r });
-      for (const s of o.linked_sessions ?? []) edges.push({ kind: 'evidence', from: `session:${s}`, to: o.id });
-      if (o.type === 'idea' && o.promoted_to) edges.push({ kind: 'promoted_to', from: o.id, to: o.promoted_to });
-      if (o.type === 'task' && o.plan) edges.push({ kind: 'parent_of', from: o.plan, to: o.id });
-      if (o.type === 'task' && o.scheduled_for) edges.push({ kind: 'scheduled_for', from: o.id, to: o.scheduled_for });
-      if (o.type === 'insight') for (const t of o.suggested_tasks ?? []) edges.push({ kind: 'surfaced_on', from: o.id, to: t });
-      if (o.project) edges.push({ kind: 'parent_of', from: o.project, to: o.id });
-    }
-    return edges;
-  }
-
-  /** Union of frontmatter-derived and explicit edges. */
-  allEdges(): Edge[] {
-    return [...this.frontmatterEdges(), ...this.fileEdges()];
-  }
-}
-
-/** Recursively yield absolute paths of `*.md` files, skipping IGNORE_DIRS. */
-export function walkMarkdown(root: string): string[] {
-  const out: string[] = [];
-  if (!existsSync(root)) return out;
-  const walk = (dir: string) => {
-    let entries;
-    try {
-      entries = readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const e of entries) {
-      if (e.isDirectory()) {
-        if (IGNORE_DIRS.has(e.name) || e.name.startsWith('.')) continue;
-        walk(join(dir, e.name));
-      } else if (e.isFile() && e.name.endsWith('.md')) {
-        out.push(join(dir, e.name));
-      }
-    }
-  };
-  walk(root);
-  return out;
-}

package/src/types.ts

@@ -1,18 +0,0 @@
-/** Store-level configuration (config.json at the planning repo root). */
-export interface Config {
-  /** Top-level life/work areas. */
-  domains: string[];
-  /** Absolute path to the ~/docs knowledge base (KnowledgeRef resolution root). */
-  kb_root: string;
-  /** Absolute path to the sessions.git store (~/.sessions) for planning_refs. */
-  sessions_root: string;
-  /** Team-ready fields, dormant solo. */
-  owner?: string;
-  visibility?: 'private' | 'shared';
-}
-
-export const DEFAULT_CONFIG: Config = {
-  domains: ['tech', 'career', 'finances', 'kids', 'relationship', 'relocation'],
-  kb_root: `${process.env.HOME}/docs`,
-  sessions_root: `${process.env.HOME}/.sessions`,
-};