WIP

Author: StachuDotNet

.claude/settings.local.json

@@ -18,7 +18,12 @@
       "Bash(done)",
       "Bash(/home/stachu/code/dark/scripts/build/build-release-cli-exes.sh:*)",
       "Bash(scripts/run-backend-tests:*)",
-      "Bash(timeout:*)"
+      "Bash(timeout:*)",
+      "Read(//home/stachu/code/darklang.com/**)",
+      "WebFetch(domain:code.visualstudio.com)",
+      "Bash(pandoc:*)",
+      "WebFetch(domain:lms.fargorate.com)",
+      "WebSearch"
     ],
     "deny": []
   }

2025-09-23-a-week-ago-i-had-collected-a-bunch-of-notes-about.txt

@@ -0,0 +1,100 @@
+-- ===================================
+-- Package Management System Tables
+-- ===================================
+
+-- Content storage (immutable, content-addressed)
+CREATE TABLE IF NOT EXISTS matter_content_v0 (
+  hash TEXT PRIMARY KEY,
+  content_type TEXT NOT NULL CHECK (content_type IN ('function', 'type', 'value')),
+  content BLOB NOT NULL,
+  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX idx_matter_content_type ON matter_content_v0(content_type);
+
+-- Name pointers (mutable pointers to content)
+CREATE TABLE IF NOT EXISTS matter_names_v0 (
+  id UUID PRIMARY KEY DEFAULT (uuid()),
+  owner TEXT NOT NULL,
+  modules TEXT NOT NULL,
+  name TEXT NOT NULL,
+  hash TEXT NOT NULL REFERENCES matter_content_v0(hash),
+  deprecated BOOLEAN NOT NULL DEFAULT FALSE,
+  deprecation_reason TEXT,
+  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  UNIQUE(owner, modules, name)
+);
+
+CREATE INDEX idx_matter_names_location ON matter_names_v0(owner, modules, name);
+CREATE INDEX idx_matter_names_hash ON matter_names_v0(hash);
+
+-- Instances
+CREATE TABLE IF NOT EXISTS matter_instances_v0 (
+  id UUID PRIMARY KEY DEFAULT (uuid()),
+  name TEXT NOT NULL UNIQUE,
+  instance_type TEXT NOT NULL CHECK (instance_type IN ('LocalCLI', 'HttpServer')),
+  last_sync_at TIMESTAMP,
+  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Sessions
+CREATE TABLE IF NOT EXISTS matter_sessions_v0 (
+  id UUID PRIMARY KEY DEFAULT (uuid()),
+  name TEXT NOT NULL,
+  intent TEXT NOT NULL,
+  owner TEXT NOT NULL,
+  current_patch_id UUID,
+  state TEXT NOT NULL CHECK (state IN ('Active', 'Suspended', 'Completed')),
+  workspace_state BLOB,  -- Serialized workspace state
+  started_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  last_active_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX idx_matter_sessions_owner ON matter_sessions_v0(owner);
+CREATE INDEX idx_matter_sessions_state ON matter_sessions_v0(state);
+
+-- Patches
+CREATE TABLE IF NOT EXISTS matter_patches_v0 (
+  id UUID PRIMARY KEY DEFAULT (uuid()),
+  intent TEXT NOT NULL,
+  author TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('Draft', 'Ready', 'Applied', 'Rejected')),
+  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  metadata BLOB  -- Serialized patch metadata (todos, tags, etc)
+);
+
+CREATE INDEX idx_matter_patches_author ON matter_patches_v0(author);
+CREATE INDEX idx_matter_patches_status ON matter_patches_v0(status);
+
+-- Operations
+CREATE TABLE IF NOT EXISTS matter_ops_v0 (
+  id UUID PRIMARY KEY DEFAULT (uuid()),
+  patch_id UUID NOT NULL REFERENCES matter_patches_v0(id),
+  sequence_num INTEGER NOT NULL,
+  op_type TEXT NOT NULL,
+  op_data BLOB NOT NULL,  -- Serialized Op.T
+  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  UNIQUE(patch_id, sequence_num)
+);
+
+CREATE INDEX idx_matter_ops_patch ON matter_ops_v0(patch_id);
+
+-- Patch dependencies
+CREATE TABLE IF NOT EXISTS matter_patch_dependencies_v0 (
+  patch_id UUID NOT NULL REFERENCES matter_patches_v0(id),
+  depends_on_patch_id UUID NOT NULL REFERENCES matter_patches_v0(id),
+  PRIMARY KEY (patch_id, depends_on_patch_id)
+);
+
+-- Session patches (which patches belong to which session)
+CREATE TABLE IF NOT EXISTS matter_session_patches_v0 (
+  session_id UUID NOT NULL REFERENCES matter_sessions_v0(id),
+  patch_id UUID NOT NULL REFERENCES matter_patches_v0(id),
+  added_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  PRIMARY KEY (session_id, patch_id)
+);
+
+CREATE INDEX idx_matter_session_patches_session ON matter_session_patches_v0(session_id);
+CREATE INDEX idx_matter_session_patches_patch ON matter_session_patches_v0(patch_id);

backend/migrations/20250930_000000_add_matter_tables.sql

@@ -751,3 +751,161 @@ module Toplevel =
     match tl with
     | TLDB db -> db.tlid
     | TLHandler h -> h.tlid
+
+
+/// Represents a location in the package namespace
+module PackageLocation =
+  type T = {
+    owner: string
+    modules: List<string>
+    name: string
+  }
+
+  let create (owner: string) (modules: List<string>) (name: string) : T =
+    { owner = owner; modules = modules; name = name }
+
+  let toString (location: T) : string =
+    let moduleStr =
+      if List.isEmpty location.modules then
+        ""
+      else
+        (String.concat "." location.modules) + "."
+    $"{location.owner}.{moduleStr}{location.name}"
+
+  let parse (locationString: string) : Result<T, string> =
+    let parts = locationString.Split('.') |> Array.toList
+    match parts with
+    | owner :: rest when not (List.isEmpty rest) ->
+      let reversedRest = List.rev rest
+      match reversedRest with
+      | name :: reversedModules ->
+        let modules = List.rev reversedModules
+        Ok { owner = owner; modules = modules; name = name }
+      | [] -> Error $"Invalid package location: {locationString}"
+    | _ -> Error $"Invalid package location: {locationString}"
+
+
+/// Atomic operations that can be tracked and validated
+module Op =
+  type T =
+    // Content Operations - create new immutable content
+    | AddFunctionContent of hash: string * content: PackageFn.PackageFn
+    | AddTypeContent of hash: string * content: PackageType.PackageType
+    | AddValueContent of hash: string * content: PackageValue.PackageValue
+
+    // Name Operations - manage name pointers
+    | CreateName of location: PackageLocation.T * hash: string * contentType: string
+    | UpdateNamePointer of location: PackageLocation.T * oldHash: string * newHash: string
+    | MoveName of oldLocation: PackageLocation.T * newLocation: PackageLocation.T
+    | UnassignName of location: PackageLocation.T
+
+    // Content Operations - deprecate content (by hash)
+    | DeprecateContent of hash: string * reason: string * replacement: string option
+
+
+/// Patch status workflow
+module PatchStatus =
+  type T =
+    | Draft       // Work in progress, can be modified
+    | Ready       // Complete and ready for review
+    | Applied     // Successfully applied to instance
+    | Rejected    // Rejected during validation
+
+
+/// A logical collection of operations
+module Patch =
+  type Metadata = {
+    todos: List<string>
+    tags: List<string>
+    testsCovered: List<string>
+  }
+
+  type T = {
+    id: uuid
+    intent: string                     // Human-readable description
+    ops: List<Op.T>
+    parentPatches: List<uuid>          // Patches this depends on
+    status: PatchStatus.T
+    author: string
+    createdAt: System.DateTime
+    updatedAt: System.DateTime
+    metadata: Metadata
+  }
+
+
+/// Session state
+module SessionState =
+  type T =
+    | Active
+    | Suspended
+    | Completed
+
+
+/// Working context within a session
+module WorkspaceState =
+  type T = {
+    openFiles: List<PackageLocation.T>
+    currentFile: PackageLocation.T option
+    breakpoints: List<PackageLocation.T * int>
+    bookmarks: List<PackageLocation.T * string>
+  }
+
+  let empty : T = {
+    openFiles = []
+    currentFile = None
+    breakpoints = []
+    bookmarks = []
+  }
+
+
+/// A development session
+module Session =
+  type T = {
+    id: uuid
+    name: string
+    intent: string                      // What you're working on
+    owner: string
+    patches: List<uuid>                 // Patches created in this session
+    currentPatch: uuid option
+    startedAt: System.DateTime
+    lastActiveAt: System.DateTime
+    state: SessionState.T
+    workspace: WorkspaceState.T
+  }
+
+
+/// Instance types in the Darklang ecosystem
+module InstanceType =
+  type T =
+    | LocalCLI        // Individual developer machine
+    | HttpServer   // Main Darklang package repository
+
+
+/// Darklang instance definition
+module Instance =
+  type T = {
+    id: uuid
+    type_: InstanceType.T
+    name: string
+    lastSyncAt: System.DateTime option
+  }
+
+
+/// Types of conflicts that can occur
+module Conflict =
+  type T =
+    // Two patches trying to point the same name to different content
+    | NameConflict of location: PackageLocation.T * hash1: string * hash2: string
+    // Type signature changed in incompatible way (to be defined more specifically later)
+    | TypeIncompatibility of location: PackageLocation.T * oldHash: string * newHash: string
+
+
+/// Validation results for operations and patches
+module ValidationResult =
+  type T = {
+    isValid: bool
+    conflicts: List<Conflict.T>
+    dependencies: List<PackageLocation.T>
+    warnings: List<string>
+    suggestions: List<string>
+  }

backend/src/LibExecution/ProgramTypes.fs

@@ -0,0 +1,53 @@
+module LibPackageManager.ContentStore
+
+open System.Collections.Concurrent
+open Prelude
+open LibExecution.ProgramTypes
+
+module PT = LibExecution.ProgramTypes
+
+/// Content storage - immutable content addressed by hash
+type ContentType =
+  | Function
+  | Type
+  | Value
+
+type Content =
+  | FunctionContent of PT.PackageFn.PackageFn
+  | TypeContent of PT.PackageType.PackageType
+  | ValueContent of PT.PackageValue.PackageValue
+
+type DeprecationInfo = {
+  reason: string
+  replacement: string option
+}
+
+// In-memory content cache
+let private contentCache = ConcurrentDictionary<string, Content>()
+
+// In-memory deprecation tracking
+let private deprecationCache = ConcurrentDictionary<string, DeprecationInfo>()
+
+let hashContent (content: Content) : string =
+  // For now, simple hash implementation - in production use proper hashing
+  match content with
+  | FunctionContent fn -> $"fn-{fn.id}"
+  | TypeContent t -> $"type-{t.id}"
+  | ValueContent v -> $"val-{v.id}"
+
+let addContent (hash: string) (content: Content) : unit =
+  contentCache.TryAdd(hash, content) |> ignore<bool>
+
+let getContent (hash: string) : Option<Content> =
+  match contentCache.TryGetValue(hash) with
+  | true, content -> Some content
+  | false, _ -> None
+
+let deprecateContent (hash: string) (reason: string) (replacement: string option) : unit =
+  let info = { reason = reason; replacement = replacement }
+  deprecationCache.AddOrUpdate(hash, info, fun _ _ -> info) |> ignore<DeprecationInfo>
+
+let isDeprecated (hash: string) : Option<DeprecationInfo> =
+  match deprecationCache.TryGetValue(hash) with
+  | true, info -> Some info
+  | false, _ -> None

backend/src/LibPackageManager/ContentStore.fs

@@ -24,7 +24,15 @@
     <Compile Include="Purge.fs" />
     <Compile Include="Inserts.fs" />
     <Compile Include="ProgramTypes.fs" />
+    <Compile Include="ContentStore.fs" />
+    <Compile Include="NameStore.fs" />
+    <Compile Include="SessionProjection.fs" />
+    <Compile Include="OpValidation.fs" />
+    <Compile Include="OpExecution.fs" />
+    <Compile Include="SessionStorage.fs" />
+    <Compile Include="SessionManager.fs" />
     <Compile Include="RuntimeTypes.fs" />
+    <Compile Include="SessionAwarePackageManager.fs" />
     <Compile Include="PackageManager.fs" />
     <Compile Include="Scripts.fs" />
   </ItemGroup>

backend/src/LibPackageManager/LibPackageManager.fsproj

@@ -0,0 +1,37 @@
+module LibPackageManager.NameStore
+
+open System.Collections.Concurrent
+open Prelude
+open LibExecution.ProgramTypes
+
+module PT = LibExecution.ProgramTypes
+
+/// Name resolution - maps package locations to content hashes
+type NameEntry = {
+  location: PT.PackageLocation.T
+  hash: string
+  contentType: ContentStore.ContentType
+}
+
+// In-memory name mappings
+let private nameStore = ConcurrentDictionary<string, NameEntry>()
+
+let private locationKey (location: PT.PackageLocation.T) : string =
+  PT.PackageLocation.toString location
+
+let setName (location: PT.PackageLocation.T) (hash: string) (contentType: ContentStore.ContentType) : unit =
+  let entry = {
+    location = location
+    hash = hash
+    contentType = contentType
+  }
+  nameStore.AddOrUpdate(locationKey location, entry, fun _ _ -> entry) |> ignore<NameEntry>
+
+let getName (location: PT.PackageLocation.T) : Option<NameEntry> =
+  match nameStore.TryGetValue(locationKey location) with
+  | true, entry -> Some entry
+  | false, _ -> None
+
+let deleteName (location: PT.PackageLocation.T) : bool =
+  let key = locationKey location
+  nameStore.TryRemove(key) |> fst