@kaddo/cli 3.69.1 → 3.69.2

package/dist/admin-server/index.js

@@ -0,0 +1,448 @@
+// src/server.ts
+import Fastify from "fastify";
+import fastifyCookie from "@fastify/cookie";
+import fastifyCors from "@fastify/cors";
+import fastifyStatic from "@fastify/static";
+import path from "path";
+
+// src/session.ts
+import { randomBytes } from "crypto";
+var SESSION_TTL_MS = 24 * 60 * 60 * 1e3;
+var SessionManager = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  storage;
+  activeSessionId = null;
+  createSession() {
+    this.storage.sessions.deleteExpired();
+    const id = randomBytes(32).toString("hex");
+    const now = /* @__PURE__ */ new Date();
+    const expiresAt = new Date(now.getTime() + SESSION_TTL_MS);
+    this.storage.sessions.create({
+      id,
+      createdAt: now.toISOString(),
+      expiresAt: expiresAt.toISOString()
+    });
+    this.activeSessionId = id;
+    return id;
+  }
+  validateSession(id) {
+    if (!id) return false;
+    const session = this.storage.sessions.findById(id);
+    if (!session) return false;
+    if (new Date(session.expiresAt) < /* @__PURE__ */ new Date()) {
+      this.storage.sessions.deleteById(id);
+      return false;
+    }
+    return true;
+  }
+  invalidateSession(id) {
+    this.storage.sessions.deleteById(id);
+    if (this.activeSessionId === id) this.activeSessionId = null;
+  }
+  invalidateAll() {
+    if (this.activeSessionId) {
+      this.storage.sessions.deleteById(this.activeSessionId);
+      this.activeSessionId = null;
+    }
+  }
+};
+
+// src/core-adapter.ts
+import {
+  buildProjectExplanation,
+  buildReadinessReport,
+  buildProjectRoute,
+  loadConfig,
+  loadMappedModules
+} from "@kaddo/cli/core";
+function getProjectSummary(dir) {
+  const config = loadConfig(dir);
+  if (!config) throw new CoreError("PROJECT_NOT_FOUND", "No Kaddo project was found.");
+  return {
+    name: config.project.name ?? "unknown",
+    state: config.project.state ?? "unknown",
+    structure: config.project.structure ?? "unknown",
+    language: config.project.language ?? "en",
+    teamSize: config.team.size ?? "unknown"
+  };
+}
+function getKnowledgeSummary(dir) {
+  const exp = buildProjectExplanation(dir);
+  return {
+    layers: exp.layers.map((l) => ({ layer: l.layer, status: l.status })),
+    missing: exp.missingKnowledge
+  };
+}
+function getWorkItemSummary(dir) {
+  const exp = buildProjectExplanation(dir);
+  return {
+    total: exp.workItems.total,
+    byState: exp.workItems.byState,
+    byType: exp.workItems.byType,
+    items: exp.workItems.items.map((i) => ({
+      id: i.id,
+      title: i.title,
+      type: i.type,
+      lifecycle: i.lifecycle,
+      initiative: i.initiative
+    }))
+  };
+}
+function getModules(dir) {
+  const mapped = loadMappedModules(dir);
+  return {
+    modules: mapped.map((m) => ({
+      id: m.id,
+      role: m.role,
+      path: m.path,
+      available: m.available
+    }))
+  };
+}
+function getProjectReadiness(dir) {
+  const report = buildReadinessReport(dir);
+  return {
+    overall: report.overall,
+    recommendedNextStep: {
+      label: report.nextStepRecommendation.label,
+      command: report.nextStepRecommendation.command
+    }
+  };
+}
+function getProjectRoute(dir) {
+  const route = buildProjectRoute(dir);
+  return {
+    type: route.type,
+    completed: route.completed,
+    total: route.total,
+    progressPercent: route.progressPercent,
+    steps: route.steps.map((s) => ({
+      id: s.id,
+      label: s.label,
+      status: s.status,
+      ...s.evidence ? { evidence: s.evidence } : {},
+      ...s.reason ? { reason: s.reason } : {},
+      ...s.command ? { command: s.command } : {}
+    }))
+  };
+}
+function getFindings(dir) {
+  const exp = buildProjectExplanation(dir);
+  const items = [];
+  if (exp.missingKnowledge.length > 0) {
+    for (const m of exp.missingKnowledge) {
+      items.push({ level: "warning", message: `Missing: ${m}` });
+    }
+  }
+  if (exp.duplicateWorkItems.length > 0) {
+    for (const d of exp.duplicateWorkItems) {
+      items.push({ level: "warning", message: `Possible duplicate Work Items: ${d.items.map((i) => i.id).join(", ")} (${d.reason})` });
+    }
+  }
+  const blocking = items.filter((i) => i.level === "blocking").length;
+  const warning = items.filter((i) => i.level === "warning").length;
+  const fyi = items.filter((i) => i.level === "fyi").length;
+  return { blocking, warning, fyi, items };
+}
+function getProjectOverview(dir) {
+  return {
+    project: getProjectSummary(dir),
+    knowledge: getKnowledgeSummary(dir),
+    workItems: getWorkItemSummary(dir),
+    modules: getModules(dir),
+    readiness: getProjectReadiness(dir),
+    route: getProjectRoute(dir),
+    findings: getFindings(dir)
+  };
+}
+var CoreError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "CoreError";
+  }
+  code;
+};
+
+// src/server.ts
+async function createAdminServer(opts) {
+  const { projectDir, storage, staticDir, host = "127.0.0.1", port = 4173 } = opts;
+  const app = Fastify({ logger: false });
+  const sessionManager = new SessionManager(storage);
+  await app.register(fastifyCookie);
+  await app.register(fastifyCors, {
+    origin: `http://${host}:${port}`,
+    credentials: true
+  });
+  if (staticDir) {
+    await app.register(fastifyStatic, {
+      root: path.resolve(staticDir),
+      prefix: "/",
+      wildcard: false
+    });
+  }
+  const sessionId = sessionManager.createSession();
+  app.addHook("onRequest", async (request, reply) => {
+    if (!request.url.startsWith("/api/")) return;
+    const cookieSession = request.cookies["kaddo-session"];
+    if (!sessionManager.validateSession(cookieSession)) {
+      reply.code(401).send({ error: { code: "SESSION_INVALID", message: "Invalid or expired session." } });
+    }
+  });
+  app.get("/api/v1/admin/health", async () => ({ status: "ok" }));
+  app.get("/api/v1/admin/session", async (_request, reply) => {
+    reply.setCookie("kaddo-session", sessionId, {
+      path: "/",
+      httpOnly: true,
+      sameSite: "strict",
+      maxAge: 86400
+    });
+    return { status: "active" };
+  });
+  const coreRoute = (handler) => {
+    return async () => {
+      try {
+        return handler(projectDir);
+      } catch (err) {
+        if (err instanceof CoreError) {
+          return { error: { code: err.code, message: err.message } };
+        }
+        throw err;
+      }
+    };
+  };
+  app.get("/api/v1/admin/overview", coreRoute(getProjectOverview));
+  app.get("/api/v1/admin/project", coreRoute(getProjectSummary));
+  app.get("/api/v1/admin/knowledge", coreRoute(getKnowledgeSummary));
+  app.get("/api/v1/admin/work-items", coreRoute(getWorkItemSummary));
+  app.get("/api/v1/admin/modules", coreRoute(getModules));
+  app.get("/api/v1/admin/readiness", coreRoute(getProjectReadiness));
+  app.get("/api/v1/admin/route", coreRoute(getProjectRoute));
+  app.get("/api/v1/admin/findings", coreRoute(getFindings));
+  if (staticDir) {
+    app.setNotFoundHandler(async (_request, reply) => {
+      return reply.sendFile("index.html");
+    });
+  }
+  return {
+    app,
+    sessionId,
+    sessionManager,
+    start: async () => {
+      await app.listen({ host, port });
+      return `http://${host}:${port}`;
+    },
+    stop: async () => {
+      sessionManager.invalidateAll();
+      await app.close();
+      await storage.close();
+    }
+  };
+}
+
+// src/storage/sqlite-storage.ts
+import { DatabaseSync } from "sqlite";
+var SQLiteAdminStorage = class {
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+    this.db = new DatabaseSync(dbPath);
+    this.db.exec("PRAGMA journal_mode = WAL");
+    this.sessions = {
+      create: (session) => {
+        this.db.prepare(
+          "INSERT OR REPLACE INTO admin_sessions (id, created_at, expires_at) VALUES (?, ?, ?)"
+        ).run(session.id, session.createdAt, session.expiresAt);
+      },
+      findById: (id) => {
+        const row = this.db.prepare(
+          "SELECT id, created_at, expires_at FROM admin_sessions WHERE id = ?"
+        ).get(id);
+        if (!row) return void 0;
+        return { id: row.id, createdAt: row.created_at, expiresAt: row.expires_at };
+      },
+      deleteById: (id) => {
+        this.db.prepare("DELETE FROM admin_sessions WHERE id = ?").run(id);
+      },
+      deleteExpired: () => {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        this.db.prepare("DELETE FROM admin_sessions WHERE expires_at < ?").run(now);
+      }
+    };
+    this.preferences = {
+      get: (key) => {
+        const row = this.db.prepare(
+          "SELECT value FROM admin_preferences WHERE key = ?"
+        ).get(key);
+        return row?.value;
+      },
+      set: (key, value) => {
+        this.db.prepare(
+          "INSERT OR REPLACE INTO admin_preferences (key, value) VALUES (?, ?)"
+        ).run(key, value);
+      },
+      delete: (key) => {
+        this.db.prepare("DELETE FROM admin_preferences WHERE key = ?").run(key);
+      },
+      all: () => {
+        return this.db.prepare("SELECT key, value FROM admin_preferences").all();
+      }
+    };
+    this.cache = {
+      get: (key) => {
+        const row = this.db.prepare(
+          "SELECT value, expires_at FROM admin_cache WHERE key = ?"
+        ).get(key);
+        if (!row) return void 0;
+        if (row.expires_at && new Date(row.expires_at) < /* @__PURE__ */ new Date()) {
+          this.db.prepare("DELETE FROM admin_cache WHERE key = ?").run(key);
+          return void 0;
+        }
+        return row.value;
+      },
+      set: (key, value, ttlMs) => {
+        const expiresAt = ttlMs ? new Date(Date.now() + ttlMs).toISOString() : null;
+        this.db.prepare(
+          "INSERT OR REPLACE INTO admin_cache (key, value, expires_at) VALUES (?, ?, ?)"
+        ).run(key, value, expiresAt);
+      },
+      delete: (key) => {
+        this.db.prepare("DELETE FROM admin_cache WHERE key = ?").run(key);
+      },
+      clear: () => {
+        this.db.exec("DELETE FROM admin_cache");
+      }
+    };
+  }
+  dbPath;
+  db;
+  sessions;
+  preferences;
+  cache;
+  async initialize() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS admin_sessions (
+        id TEXT PRIMARY KEY,
+        created_at TEXT NOT NULL,
+        expires_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS admin_preferences (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS admin_cache (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        expires_at TEXT
+      );
+      CREATE TABLE IF NOT EXISTS audit_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        timestamp TEXT NOT NULL,
+        action TEXT NOT NULL,
+        detail TEXT
+      );
+    `);
+  }
+  async close() {
+    this.db.close();
+  }
+};
+
+// src/contracts/schemas.ts
+import { z } from "zod";
+var ProjectSummarySchema = z.object({
+  name: z.string(),
+  state: z.string(),
+  structure: z.string(),
+  language: z.string(),
+  teamSize: z.string()
+});
+var KnowledgeSummarySchema = z.object({
+  layers: z.array(z.object({
+    layer: z.string(),
+    status: z.string()
+  })),
+  missing: z.array(z.string())
+});
+var WorkItemSummarySchema = z.object({
+  total: z.number(),
+  byState: z.record(z.string(), z.number()),
+  byType: z.record(z.string(), z.number()),
+  items: z.array(z.object({
+    id: z.string(),
+    title: z.string(),
+    type: z.string(),
+    lifecycle: z.string(),
+    initiative: z.string()
+  }))
+});
+var ModuleSummarySchema = z.object({
+  modules: z.array(z.object({
+    id: z.string(),
+    role: z.string(),
+    path: z.string().optional(),
+    available: z.boolean()
+  }))
+});
+var ProjectReadinessSchema = z.object({
+  overall: z.string(),
+  recommendedNextStep: z.object({
+    label: z.string(),
+    command: z.string().optional()
+  })
+});
+var RouteStepSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  status: z.string(),
+  evidence: z.array(z.string()).optional(),
+  reason: z.string().optional(),
+  command: z.string().optional()
+});
+var ProjectRouteSchema = z.object({
+  type: z.string(),
+  completed: z.number(),
+  total: z.number(),
+  progressPercent: z.number(),
+  steps: z.array(RouteStepSchema)
+});
+var FindingsSummarySchema = z.object({
+  blocking: z.number(),
+  warning: z.number(),
+  fyi: z.number(),
+  items: z.array(z.object({
+    level: z.enum(["blocking", "warning", "fyi"]),
+    message: z.string()
+  }))
+});
+var ProjectOverviewSchema = z.object({
+  project: ProjectSummarySchema,
+  knowledge: KnowledgeSummarySchema,
+  workItems: WorkItemSummarySchema,
+  modules: ModuleSummarySchema,
+  readiness: ProjectReadinessSchema,
+  route: ProjectRouteSchema,
+  findings: FindingsSummarySchema
+});
+var ErrorResponseSchema = z.object({
+  error: z.object({
+    code: z.string(),
+    message: z.string()
+  })
+});
+export {
+  ErrorResponseSchema,
+  FindingsSummarySchema,
+  KnowledgeSummarySchema,
+  ModuleSummarySchema,
+  ProjectOverviewSchema,
+  ProjectReadinessSchema,
+  ProjectRouteSchema,
+  ProjectSummarySchema,
+  RouteStepSchema,
+  SQLiteAdminStorage,
+  SessionManager,
+  WorkItemSummarySchema,
+  createAdminServer
+};

package/dist/index.js

@@ -18510,8 +18510,8 @@ function isPortAvailable(port, host) {
 function resolveStaticDir() {
   const __dirname = path8.dirname(fileURLToPath2(import.meta.url));
   const candidates = [
-    // Bundled inside CLI package (npm install)
-    path8.resolve(__dirname, "..", "admin-dist"),
+    // Bundled inside CLI dist (npm install)
+    path8.resolve(__dirname, "admin-dist"),
     // Monorepo development
     path8.resolve(__dirname, "..", "..", "admin", "dist"),
     path8.resolve(__dirname, "..", "node_modules", "@kaddo", "admin", "dist")
@@ -18554,7 +18554,19 @@ async function runAdmin(opts = {}) {
     console.error("Admin frontend not built. Run `pnpm -r build` first.");
     process.exit(1);
   }
-  const { createAdminServer, SQLiteAdminStorage } = await import("@kaddo/admin-server");
+  let adminServer;
+  try {
+    const __dirname = path8.dirname(fileURLToPath2(import.meta.url));
+    const bundled = path8.resolve(__dirname, "admin-server", "index.js");
+    if (exists(bundled)) {
+      adminServer = await import(bundled);
+    } else {
+      adminServer = await import("@kaddo/admin-server");
+    }
+  } catch {
+    adminServer = await import("@kaddo/admin-server");
+  }
+  const { createAdminServer, SQLiteAdminStorage } = adminServer;
   const dbDir = join(dir, ".kaddo", "admin");
   ensureDir(dbDir);
   const dbPath = join(dbDir, "admin.db");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaddo/cli",
-  "version": "3.69.1",
+  "version": "3.69.2",
   "description": "Knowledge Driven Development toolkit",
   "license": "MIT",
   "repository": {
@@ -29,7 +29,6 @@
   },
   "files": [
     "dist",
-    "dist/admin-dist",
     "README.md",
     "LICENSE"
   ],
@@ -37,7 +36,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsup && node -e \"const fs=require('fs');const s='../admin/dist',d='dist/admin-dist';if(fs.existsSync(s)){fs.cpSync(s,d,{recursive:true})}\"",
+    "build": "tsup && node -e \"const fs=require('fs');[['../admin/dist','dist/admin-dist'],['../admin-server/dist','dist/admin-server']].forEach(([s,d])=>{if(fs.existsSync(s)){fs.cpSync(s,d,{recursive:true})}})\"",
     "dev": "tsup --watch",
     "test": "vitest run",
     "prepublishOnly": "npm run build"