archctx 0.1.1 → 0.1.3

package/bin/archctx.mjs

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 // @bun
 import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
@@ -667,7 +667,7 @@ function productVersionManifest() {
     }
   };
 }
-var ARCHCONTEXT_PRODUCT_NAME = "archctx", ARCHCONTEXT_PRODUCT_VERSION = "0.1.1", ARCHCONTEXT_PACKAGE_MANAGER = "bun@1.3.10", ARCHCONTEXT_NODE_RANGE = ">=24 <26", LOCAL_RUNTIME_RPC_SCHEMA_VERSION = "archcontext.runtime-rpc/v1", ARCHCONTEXT_SCHEMA_SET_VERSION = "2026-06-20.fg1";
+var ARCHCONTEXT_PRODUCT_NAME = "archctx", ARCHCONTEXT_PRODUCT_VERSION = "0.1.3", ARCHCONTEXT_PACKAGE_MANAGER = "bun@1.3.10", ARCHCONTEXT_NODE_RANGE = ">=24 <26", LOCAL_RUNTIME_RPC_SCHEMA_VERSION = "archcontext.runtime-rpc/v1", ARCHCONTEXT_SCHEMA_SET_VERSION = "2026-06-20.fg1";
 // packages/contracts/src/index.ts
 var init_src = __esm(() => {
   init_control_plane_routes();
@@ -6538,14 +6538,25 @@ function listFiles(root) {
 // packages/local-runtime/local-store-sqlite/src/index.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { createHash as createHash5, randomUUID } from "node:crypto";
-import { chmodSync, closeSync as closeSync3, existsSync as existsSync3, fsyncSync as fsyncSync2, mkdirSync as mkdirSync2, openSync as openSync3, readFileSync as readFileSync5, realpathSync as realpathSync4, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { chmodSync, closeSync as closeSync3, existsSync as existsSync3, fsyncSync as fsyncSync2, lstatSync as lstatSync2, mkdirSync as mkdirSync2, openSync as openSync3, readFileSync as readFileSync5, realpathSync as realpathSync4, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { homedir } from "node:os";
-import { dirname as dirname2, isAbsolute as isAbsolute3, join as join2, resolve as resolve6 } from "node:path";
+import { dirname as dirname2, isAbsolute as isAbsolute3, join as join2, relative as relative4, resolve as resolve6 } from "node:path";
 var runtimeRequire = createRequire2(import.meta.url);
 var SQLITE_SIDECAR_SUFFIXES = ["", "-wal", "-shm"];
 var LEGACY_MIGRATION_MARKER_FILE = "runtime.sqlite.migration.json";
 var LEGACY_MIGRATION_LOCK_FILE = "runtime.sqlite.migration.lock";
+var REQUIRED_LOCAL_STORE_TABLES = [
+  "schema_migrations",
+  "repository_sessions",
+  "snapshots",
+  "task_states",
+  "observed_evidence",
+  "review_results",
+  "landscapes",
+  "cross_repo_edges",
+  "changeset_journal"
+];
 var SQLITE_PRAGMAS = [
   "PRAGMA journal_mode = WAL",
   "PRAGMA foreign_keys = ON",
@@ -6708,7 +6719,7 @@ function inspectLegacyLocalStoreMigration(root = process.cwd(), env = process.en
   const legacyExists = existsSync3(paths.legacyLocalStorePath);
   const targetExists = existsSync3(paths.localStorePath);
   if (targetExists) {
-    const target = safeSqliteIntegrityCheck(paths.localStorePath);
+    const target = safeCurrentLocalStoreCheck(paths.localStorePath);
     return legacyMigrationResult(false, "target-exists", paths, [], {
       status: target.ok ? "target-current" : "target-incomplete",
       integrityCheck: target.ok ? { target: target.result } : { target: "failed", error: target.error }
@@ -6719,6 +6730,13 @@ function inspectLegacyLocalStoreMigration(root = process.cwd(), env = process.en
       status: "legacy-missing"
     });
   }
+  const source = safeTrustedLegacyLocalStoreSourceCheck(paths);
+  if (!source.ok) {
+    return legacyMigrationResult(false, undefined, paths, [], {
+      status: "legacy-invalid",
+      integrityCheck: { legacy: "failed", error: source.error }
+    });
+  }
   const legacy = safeSqliteIntegrityCheck(paths.legacyLocalStorePath);
   return legacyMigrationResult(false, undefined, paths, [], {
     status: legacy.ok ? "pending" : "legacy-invalid",
@@ -6736,9 +6754,10 @@ function migrateLegacyLocalStoreIfNeeded(root = process.cwd(), env = process.env
   const legacyExists = existsSync3(paths.legacyLocalStorePath);
   const integrityCheck = {};
   const quarantinedFiles = [];
-  if (existsSync3(paths.localStorePath)) {
+  const targetExists = existsSync3(paths.localStorePath);
+  if (targetExists) {
     try {
-      integrityCheck.target = assertSqliteIntegrity(paths.localStorePath);
+      integrityCheck.target = assertCurrentLocalStore(paths.localStorePath);
       return legacyMigrationResult(false, "target-exists", paths, [], {
         status: "target-current",
         integrityCheck
@@ -6749,7 +6768,6 @@ function migrateLegacyLocalStoreIfNeeded(root = process.cwd(), env = process.env
       if (!legacyExists) {
         throw new Error(`ArchContext runtime state target is not a valid SQLite database and no legacy store is available: ${paths.localStorePath}`);
       }
-      quarantinedFiles.push(...quarantineExistingLocalStore(paths));
     }
   }
   if (!legacyExists) {
@@ -6758,18 +6776,21 @@ function migrateLegacyLocalStoreIfNeeded(root = process.cwd(), env = process.env
       integrityCheck
     });
   }
+  assertTrustedLegacyLocalStoreSource(paths);
   const lock = acquireLegacyMigrationLock(paths);
   const stagingDir = join2(paths.workspaceStateDir, `.runtime.sqlite.migration-${process.pid}-${randomUUID()}`);
   const stagingPath = join2(stagingDir, "runtime.sqlite");
   try {
+    if (targetExists)
+      quarantinedFiles.push(...quarantineExistingLocalStore(paths));
     ensurePrivateDir(stagingDir);
     integrityCheck.legacy = vacuumLegacySqliteInto(paths.legacyLocalStorePath, stagingPath);
     makePrivateFile(stagingPath);
     migrateSqliteDatabaseSync(stagingPath);
     compactSqliteDatabase(stagingPath);
-    integrityCheck.staging = assertSqliteIntegrity(stagingPath);
+    integrityCheck.staging = assertCurrentLocalStore(stagingPath);
     publishStagedLocalStore(stagingPath, paths.localStorePath);
-    integrityCheck.target = assertSqliteIntegrity(paths.localStorePath);
+    integrityCheck.target = assertCurrentLocalStore(paths.localStorePath);
     const markerPath = writeLegacyMigrationMarker(paths, integrityCheck, quarantinedFiles);
     return legacyMigrationResult(true, undefined, paths, [paths.localStorePath], {
       status: quarantinedFiles.length > 0 ? "target-quarantined-and-migrated" : "migrated",
@@ -6830,6 +6851,21 @@ function safeSqliteIntegrityCheck(path) {
     return { ok: false, error: error instanceof Error ? error.message : String(error) };
   }
 }
+function safeCurrentLocalStoreCheck(path) {
+  try {
+    return { ok: true, result: assertCurrentLocalStore(path) };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function safeTrustedLegacyLocalStoreSourceCheck(paths) {
+  try {
+    assertTrustedLegacyLocalStoreSource(paths);
+    return { ok: true };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
 function assertSqliteIntegrity(path) {
   const db = openSqliteDatabaseSync(path);
   try {
@@ -6843,6 +6879,42 @@ function assertSqliteIntegrity(path) {
     db.close();
   }
 }
+function assertCurrentLocalStore(path) {
+  const db = openSqliteDatabaseSync(path);
+  try {
+    db.exec("PRAGMA busy_timeout = 5000");
+    const integrity = sqliteIntegrityCheckOpenDatabase(db, path);
+    assertCurrentLocalStoreSchema(db, path);
+    return integrity;
+  } finally {
+    db.close();
+  }
+}
+function assertCurrentLocalStoreSchema(db, path) {
+  const tables = new Set(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((row) => String(row.name)));
+  const missingTables = REQUIRED_LOCAL_STORE_TABLES.filter((table) => !tables.has(table));
+  if (missingTables.length > 0) {
+    throw new Error(`SQLite local store schema incomplete for ${path}: missing tables ${missingTables.join(", ")}`);
+  }
+  const migrations = new Set(db.prepare("SELECT id FROM schema_migrations").all().map((row) => String(row.id)));
+  const missingMigrations = LOCAL_SQLITE_MIGRATIONS.map((migration) => migration.id).filter((id) => !migrations.has(id));
+  if (missingMigrations.length > 0) {
+    throw new Error(`SQLite local store schema incomplete for ${path}: missing migrations ${missingMigrations.join(", ")}`);
+  }
+}
+function assertTrustedLegacyLocalStoreSource(paths) {
+  const stat = lstatSync2(paths.legacyLocalStorePath);
+  if (stat.isSymbolicLink()) {
+    throw new Error(`Legacy SQLite source must not be a symbolic link: ${paths.legacyLocalStorePath}`);
+  }
+  if (!stat.isFile()) {
+    throw new Error(`Legacy SQLite source must be a regular file: ${paths.legacyLocalStorePath}`);
+  }
+  const sourceRealPath = realpathSync4.native(paths.legacyLocalStorePath);
+  if (!isPathInsideOrSame(sourceRealPath, paths.repositoryRoot)) {
+    throw new Error(`Legacy SQLite source must stay inside the repository root: ${paths.legacyLocalStorePath}`);
+  }
+}
 function vacuumLegacySqliteInto(sourcePath, targetPath) {
   const db = openSqliteDatabaseSync(sourcePath);
   try {
@@ -7042,6 +7114,12 @@ function canonicalPath(path) {
     return resolved;
   }
 }
+function isPathInsideOrSame(path, parent) {
+  const child = resolve6(path);
+  const base = resolve6(parent);
+  const fromBase = relative4(base, child);
+  return fromBase === "" || !!fromBase && !fromBase.startsWith("..") && !isAbsolute3(fromBase);
+}
 function stableStorageId(prefix, value) {
   return `${prefix}.${createHash5("sha256").update(value).digest("hex").slice(0, 16)}`;
 }
@@ -7326,15 +7404,26 @@ function isGitWorktreeError(error) {
 // packages/local-runtime/local-store-sqlite/src/index.ts
 import { execFileSync as execFileSync5 } from "node:child_process";
 import { createHash as createHash6, randomUUID as randomUUID2 } from "node:crypto";
-import { chmodSync as chmodSync2, closeSync as closeSync4, existsSync as existsSync6, fsyncSync as fsyncSync3, mkdirSync as mkdirSync5, openSync as openSync4, readFileSync as readFileSync6, realpathSync as realpathSync5, renameSync as renameSync3, rmSync as rmSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { chmodSync as chmodSync2, closeSync as closeSync4, existsSync as existsSync6, fsyncSync as fsyncSync3, lstatSync as lstatSync3, mkdirSync as mkdirSync5, openSync as openSync4, readFileSync as readFileSync6, realpathSync as realpathSync5, renameSync as renameSync3, rmSync as rmSync5, writeFileSync as writeFileSync3 } from "node:fs";
 import { readdir, readFile } from "node:fs/promises";
 import { createRequire as createRequire3 } from "node:module";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname5, isAbsolute as isAbsolute4, join as join5, resolve as resolve9 } from "node:path";
+import { dirname as dirname5, isAbsolute as isAbsolute4, join as join5, relative as relative5, resolve as resolve9 } from "node:path";
 var runtimeRequire2 = createRequire3(import.meta.url);
 var SQLITE_SIDECAR_SUFFIXES2 = ["", "-wal", "-shm"];
 var LEGACY_MIGRATION_MARKER_FILE2 = "runtime.sqlite.migration.json";
 var LEGACY_MIGRATION_LOCK_FILE2 = "runtime.sqlite.migration.lock";
+var REQUIRED_LOCAL_STORE_TABLES2 = [
+  "schema_migrations",
+  "repository_sessions",
+  "snapshots",
+  "task_states",
+  "observed_evidence",
+  "review_results",
+  "landscapes",
+  "cross_repo_edges",
+  "changeset_journal"
+];
 var SQLITE_PRAGMAS2 = [
   "PRAGMA journal_mode = WAL",
   "PRAGMA foreign_keys = ON",
@@ -7498,9 +7587,10 @@ function migrateLegacyLocalStoreIfNeeded2(root = process.cwd(), env = process.en
   const legacyExists = existsSync6(paths.legacyLocalStorePath);
   const integrityCheck = {};
   const quarantinedFiles = [];
-  if (existsSync6(paths.localStorePath)) {
+  const targetExists = existsSync6(paths.localStorePath);
+  if (targetExists) {
     try {
-      integrityCheck.target = assertSqliteIntegrity2(paths.localStorePath);
+      integrityCheck.target = assertCurrentLocalStore2(paths.localStorePath);
       return legacyMigrationResult2(false, "target-exists", paths, [], {
         status: "target-current",
         integrityCheck
@@ -7511,7 +7601,6 @@ function migrateLegacyLocalStoreIfNeeded2(root = process.cwd(), env = process.en
       if (!legacyExists) {
         throw new Error(`ArchContext runtime state target is not a valid SQLite database and no legacy store is available: ${paths.localStorePath}`);
       }
-      quarantinedFiles.push(...quarantineExistingLocalStore2(paths));
     }
   }
   if (!legacyExists) {
@@ -7520,18 +7609,21 @@ function migrateLegacyLocalStoreIfNeeded2(root = process.cwd(), env = process.en
       integrityCheck
     });
   }
+  assertTrustedLegacyLocalStoreSource2(paths);
   const lock = acquireLegacyMigrationLock2(paths);
   const stagingDir = join5(paths.workspaceStateDir, `.runtime.sqlite.migration-${process.pid}-${randomUUID2()}`);
   const stagingPath = join5(stagingDir, "runtime.sqlite");
   try {
+    if (targetExists)
+      quarantinedFiles.push(...quarantineExistingLocalStore2(paths));
     ensurePrivateDir2(stagingDir);
     integrityCheck.legacy = vacuumLegacySqliteInto2(paths.legacyLocalStorePath, stagingPath);
     makePrivateFile2(stagingPath);
     migrateSqliteDatabaseSync2(stagingPath);
     compactSqliteDatabase2(stagingPath);
-    integrityCheck.staging = assertSqliteIntegrity2(stagingPath);
+    integrityCheck.staging = assertCurrentLocalStore2(stagingPath);
     publishStagedLocalStore2(stagingPath, paths.localStorePath);
-    integrityCheck.target = assertSqliteIntegrity2(paths.localStorePath);
+    integrityCheck.target = assertCurrentLocalStore2(paths.localStorePath);
     const markerPath = writeLegacyMigrationMarker2(paths, integrityCheck, quarantinedFiles);
     return legacyMigrationResult2(true, undefined, paths, [paths.localStorePath], {
       status: quarantinedFiles.length > 0 ? "target-quarantined-and-migrated" : "migrated",
@@ -7798,19 +7890,42 @@ function legacyMigrationResult2(migrated, skippedReason, paths, copiedFiles, det
     quarantinedFiles: details.quarantinedFiles ?? []
   };
 }
-function assertSqliteIntegrity2(path) {
+function assertCurrentLocalStore2(path) {
   const db = openSqliteDatabaseSync2(path);
   try {
     db.exec("PRAGMA busy_timeout = 5000");
-    const row = db.prepare("PRAGMA integrity_check").get();
-    const result = firstSqliteColumn2(row);
-    if (result !== "ok")
-      throw new Error(`SQLite integrity_check failed for ${path}: ${result}`);
-    return result;
+    const integrity = sqliteIntegrityCheckOpenDatabase2(db, path);
+    assertCurrentLocalStoreSchema2(db, path);
+    return integrity;
   } finally {
     db.close();
   }
 }
+function assertCurrentLocalStoreSchema2(db, path) {
+  const tables = new Set(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((row) => String(row.name)));
+  const missingTables = REQUIRED_LOCAL_STORE_TABLES2.filter((table) => !tables.has(table));
+  if (missingTables.length > 0) {
+    throw new Error(`SQLite local store schema incomplete for ${path}: missing tables ${missingTables.join(", ")}`);
+  }
+  const migrations = new Set(db.prepare("SELECT id FROM schema_migrations").all().map((row) => String(row.id)));
+  const missingMigrations = LOCAL_SQLITE_MIGRATIONS2.map((migration) => migration.id).filter((id) => !migrations.has(id));
+  if (missingMigrations.length > 0) {
+    throw new Error(`SQLite local store schema incomplete for ${path}: missing migrations ${missingMigrations.join(", ")}`);
+  }
+}
+function assertTrustedLegacyLocalStoreSource2(paths) {
+  const stat = lstatSync3(paths.legacyLocalStorePath);
+  if (stat.isSymbolicLink()) {
+    throw new Error(`Legacy SQLite source must not be a symbolic link: ${paths.legacyLocalStorePath}`);
+  }
+  if (!stat.isFile()) {
+    throw new Error(`Legacy SQLite source must be a regular file: ${paths.legacyLocalStorePath}`);
+  }
+  const sourceRealPath = realpathSync5.native(paths.legacyLocalStorePath);
+  if (!isPathInsideOrSame2(sourceRealPath, paths.repositoryRoot)) {
+    throw new Error(`Legacy SQLite source must stay inside the repository root: ${paths.legacyLocalStorePath}`);
+  }
+}
 function vacuumLegacySqliteInto2(sourcePath, targetPath) {
   const db = openSqliteDatabaseSync2(sourcePath);
   try {
@@ -8010,6 +8125,12 @@ function canonicalPath2(path) {
     return resolved;
   }
 }
+function isPathInsideOrSame2(path, parent) {
+  const child = resolve9(path);
+  const base = resolve9(parent);
+  const fromBase = relative5(base, child);
+  return fromBase === "" || !!fromBase && !fromBase.startsWith("..") && !isAbsolute4(fromBase);
+}
 function stableStorageId2(prefix, value) {
   return `${prefix}.${createHash6("sha256").update(value).digest("hex").slice(0, 16)}`;
 }

package/bin/codegraph.mjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+const require = createRequire(import.meta.url);
+const packageJson = require.resolve("@colbymchenry/codegraph/package.json");
+require(join(dirname(packageJson), "npm-shim.js"));

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "archctx",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Local architecture context CLI for agentic coding workflows.",
   "private": false,
   "type": "module",
   "bin": {
-    "archctx": "./bin/archctx.mjs"
+    "archctx": "./bin/archctx.mjs",
+    "codegraph": "./bin/codegraph.mjs"
   },
-  "packageManager": "bun@1.3.10",
   "files": [
     "bin",
     "README.md"
@@ -18,8 +18,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "engines": {
-    "node": ">=24 <26",
-    "bun": ">=1.3.10"
+    "node": ">=24 <26"
   },
   "dependencies": {
     "@colbymchenry/codegraph": "1.0.1"