kabanos 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] — 2026-06-23
+
+### Added
+
+- Comment scanner for TypeScript/JavaScript/JSX/TSX, Python, Go, Rust, CSS/SCSS, and HTML with `.gitignore` support, project-root containment, file-size limits, incremental mtime/size caching, and a pluggable custom parser API.
+- Board reconciliation lifecycle: create cards from new comments, update moved or changed comments, archive removed comments, resolve cards without touching source files, and suppress resolved fingerprints on future scans.
+- SQL persistence layer via Kysely with SQLite (default), PostgreSQL, and MySQL adapters. Schema migrations run automatically and are versioned — safe to upgrade without manual intervention.
+- Fetch-compatible core API with auth guard enforcement, actor resolution, JSON/origin mutation checks, source-context endpoint, settings and column management endpoints, and manual scan trigger.
+- Framework adapters: Express, Fastify, Next.js route handler, and generic Node `http`.
+- React kanban UI with light/dark Notion-derived theme tokens, drag-and-drop, keyboard column movement, card details panel, notes, assignee, labels, source context viewer, scan trigger, settings panel, column management, and scan path overrides.
+- `kabanos init` CLI that generates `kanban.config.ts` and prints a framework-specific mounting snippet without modifying host application source files.
+- Runnable demo (`pnpm demo`) with multi-language sample project (TypeScript, Python, Go, CSS, HTML).
+
+### Fixed
+
+- Card position accounting in multi-column reconcile runs: positions are now tracked per-column so newly created cards in one column no longer inflate position indices for cards created in other columns in the same scan.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FP2003
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,120 @@
+# Kabanos
+
+Kabanos turns `TODO` and `FIXME` comments into a kanban board mounted inside an existing Node.js application. Source files are always read-only: resolving a card records state in the configured database and never rewrites the comment.
+
+## Requirements
+
+- Node.js 20 or newer
+- An explicit host authorization guard, or an explicit public-mode opt-out
+
+## Install and initialize
+
+```sh
+npm install kabanos
+npx kabanos init
+```
+
+pnpm blocks native dependency install scripts unless explicitly approved. When pnpm reports that `better-sqlite3` was ignored, run `pnpm approve-builds` and approve that package before using the default SQLite adapter.
+
+The initializer creates `kanban.config.ts` and `.kanban/`, then prints a framework-specific mounting snippet. It does not modify application source files. Add `.kanban/` to `.gitignore` when using SQLite.
+
+## Runnable demo
+
+```sh
+npx pnpm demo
+```
+
+Open `http://127.0.0.1:3000/admin/kb`. The demo scans sample TypeScript, Python, Go, CSS, and HTML comments and persists board state under the ignored `demo/project/.kanban/` directory.
+
+To restore all demo cards to their initial state:
+
+```sh
+npx pnpm demo:reset
+```
+
+## Express example
+
+```ts
+import express from 'express';
+import config from './kanban.config.js';
+import { createKabanos } from 'kabanos';
+import { createExpressMiddleware } from 'kabanos/express';
+
+const app = express();
+app.use(express.json());
+
+const kabanos = await createKabanos(config);
+app.use(config.mountPath, createExpressMiddleware(kabanos));
+
+const server = app.listen(3000);
+process.once('SIGTERM', async () => {
+  server.close();
+  await kabanos.close();
+});
+```
+
+Equivalent entrypoints are exported as `kabanos/fastify`, `kabanos/next`, and `kabanos/node`.
+
+## Configuration
+
+```ts
+import { defineConfig } from 'kabanos';
+
+export default defineConfig({
+  projectRoot: process.cwd(),
+  mountPath: '/admin/kb',
+  columns: [
+    { id: 'backlog', name: 'Backlog' },
+    { id: 'in-progress', name: 'In Progress' },
+    { id: 'done', name: 'Done', completion: true },
+  ],
+  scan: {
+    include: ['src/**/*.{ts,tsx,js,jsx,py,go,rs,css,scss,html}'],
+    exclude: ['**/*.test.*'],
+    tags: {
+      TODO: { column: 'backlog', priority: 'normal' },
+      FIXME: { column: 'in-progress', priority: 'high' },
+    },
+    watch: process.env.NODE_ENV === 'development',
+  },
+  storage: { adapter: 'sqlite', filename: '.kanban/board.db' },
+  theme: { default: 'system' },
+  auth: {
+    guard: request => request.user?.role === 'admin',
+    actor: request => request.user
+      ? { id: String(request.user.id), name: request.user.name }
+      : undefined,
+  },
+});
+```
+
+Exactly one column must have `completion: true`. String-only column arrays remain supported; the final string becomes the completion column. UI changes are stored as database overrides without rewriting the configuration file.
+
+For PostgreSQL or MySQL, select the corresponding adapter and provide `connectionString`. The `pg` and `mysql2` drivers are optional dependencies. Schema migrations run automatically on startup — no manual migration step required.
+
+## Lifecycle and safety
+
+- New tagged comments create cards.
+- Moving or editing surrounding lines retains the card through content/context matching.
+- Editing an open comment updates and flags its card.
+- Deleting a comment archives its card on the next scan.
+- Resolving a card stores its fingerprint and suppresses rediscovery.
+- Editing a resolved comment changes its fingerprint and creates new work.
+- Symlinks are not followed, configured ignores and `.gitignore` are honored, and source context access is confined to `projectRoot`.
+
+The package does not contain a source-writing API.
+
+## Development
+
+```sh
+pnpm install
+pnpm typecheck
+pnpm test
+pnpm test:benchmark
+PLAYWRIGHT_CHROMIUM_PATH=/usr/bin/chromium pnpm test:e2e
+docker compose -f compose.test.yml up -d --wait
+pnpm test:databases
+docker compose -f compose.test.yml down -v
+pnpm build
+pnpm pack
+```

package/dist/adapters/express.d.ts

@@ -0,0 +1,7 @@
+import { RequestHandler } from 'express';
+import { K as KabanosInstance } from '../core-C0gUmthe.js';
+import 'node:http';
+
+declare function createExpressMiddleware(instance: KabanosInstance): RequestHandler;
+
+export { createExpressMiddleware };

package/dist/adapters/express.js

@@ -0,0 +1,22 @@
+// src/adapters/express.ts
+import { Readable } from "stream";
+function createExpressMiddleware(instance) {
+  return async (req, res, next) => {
+    try {
+      const origin = `${req.protocol}://${req.get("host") ?? "localhost"}`;
+      const body = ["GET", "HEAD"].includes(req.method) ? void 0 : req.body !== void 0 ? JSON.stringify(req.body) : void 0;
+      const request = new globalThis.Request(new URL(req.originalUrl, origin), { method: req.method, headers: req.headers, body });
+      const response = await instance.handler(request, req);
+      res.status(response.status);
+      response.headers.forEach((value, key) => res.setHeader(key, value));
+      if (response.body) Readable.fromWeb(response.body).pipe(res);
+      else res.end();
+    } catch (error) {
+      next(error);
+    }
+  };
+}
+export {
+  createExpressMiddleware
+};
+//# sourceMappingURL=express.js.map

package/dist/adapters/express.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/express.ts"],"sourcesContent":["import type { Request, RequestHandler, Response } from 'express';\nimport { Readable } from 'node:stream';\nimport type { KabanosInstance } from '../core.js';\n\nexport function createExpressMiddleware(instance:KabanosInstance):RequestHandler{return async(req:Request,res:Response,next)=>{try{const origin=`${req.protocol}://${req.get('host')??'localhost'}`;const body=['GET','HEAD'].includes(req.method)?undefined:req.body!==undefined?JSON.stringify(req.body):undefined;const request=new globalThis.Request(new URL(req.originalUrl,origin),{method:req.method,headers:req.headers as HeadersInit,body});const response=await instance.handler(request,req);res.status(response.status);response.headers.forEach((value,key)=>res.setHeader(key,value));if(response.body)Readable.fromWeb(response.body as never).pipe(res);else res.end();}catch(error){next(error);}};}\n"],"mappings":";AACA,SAAS,gBAAgB;AAGlB,SAAS,wBAAwB,UAAwC;AAAC,SAAO,OAAM,KAAY,KAAa,SAAO;AAAC,QAAG;AAAC,YAAM,SAAO,GAAG,IAAI,QAAQ,MAAM,IAAI,IAAI,MAAM,KAAG,WAAW;AAAG,YAAM,OAAK,CAAC,OAAM,MAAM,EAAE,SAAS,IAAI,MAAM,IAAE,SAAU,IAAI,SAAO,SAAU,KAAK,UAAU,IAAI,IAAI,IAAE;AAAU,YAAM,UAAQ,IAAI,WAAW,QAAQ,IAAI,IAAI,IAAI,aAAY,MAAM,GAAE,EAAC,QAAO,IAAI,QAAO,SAAQ,IAAI,SAAuB,KAAI,CAAC;AAAE,YAAM,WAAS,MAAM,SAAS,QAAQ,SAAQ,GAAG;AAAE,UAAI,OAAO,SAAS,MAAM;AAAE,eAAS,QAAQ,QAAQ,CAAC,OAAM,QAAM,IAAI,UAAU,KAAI,KAAK,CAAC;AAAE,UAAG,SAAS,KAAK,UAAS,QAAQ,SAAS,IAAa,EAAE,KAAK,GAAG;AAAA,UAAO,KAAI,IAAI;AAAA,IAAE,SAAO,OAAM;AAAC,WAAK,KAAK;AAAA,IAAE;AAAA,EAAC;AAAE;","names":[]}

package/dist/adapters/fastify.d.ts

@@ -0,0 +1,7 @@
+import { FastifyPluginAsync } from 'fastify';
+import { K as KabanosInstance } from '../core-C0gUmthe.js';
+import 'node:http';
+
+declare function kabanosFastify(instance: KabanosInstance): FastifyPluginAsync;
+
+export { kabanosFastify };

package/dist/adapters/fastify.js

@@ -0,0 +1,19 @@
+// src/adapters/fastify.ts
+function kabanosFastify(instance) {
+  return async (fastify) => {
+    const handler = async (request, reply) => {
+      const origin = `${request.protocol}://${request.host}`;
+      const web = new Request(new URL(request.url, origin), { method: request.method, headers: request.headers, body: ["GET", "HEAD"].includes(request.method) ? void 0 : JSON.stringify(request.body) });
+      const response = await instance.handler(web, request);
+      reply.status(response.status);
+      response.headers.forEach((value, key) => reply.header(key, value));
+      return reply.send(Buffer.from(await response.arrayBuffer()));
+    };
+    fastify.all(instance.config.mountPath, handler);
+    fastify.all(`${instance.config.mountPath}/*`, handler);
+  };
+}
+export {
+  kabanosFastify
+};
+//# sourceMappingURL=fastify.js.map

package/dist/adapters/fastify.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/fastify.ts"],"sourcesContent":["import type { FastifyPluginAsync, FastifyReply, FastifyRequest } from 'fastify';\nimport type { KabanosInstance } from '../core.js';\n\nexport function kabanosFastify(instance:KabanosInstance):FastifyPluginAsync{return async fastify=>{const handler=async(request:FastifyRequest,reply:FastifyReply)=>{const origin=`${request.protocol}://${request.host}`;const web=new Request(new URL(request.url,origin),{method:request.method,headers:request.headers as HeadersInit,body:['GET','HEAD'].includes(request.method)?undefined:JSON.stringify(request.body)});const response=await instance.handler(web,request);reply.status(response.status);response.headers.forEach((value,key)=>reply.header(key,value));return reply.send(Buffer.from(await response.arrayBuffer()));};fastify.all(instance.config.mountPath,handler);fastify.all(`${instance.config.mountPath}/*`,handler);};}\n"],"mappings":";AAGO,SAAS,eAAe,UAA4C;AAAC,SAAO,OAAM,YAAS;AAAC,UAAM,UAAQ,OAAM,SAAuB,UAAqB;AAAC,YAAM,SAAO,GAAG,QAAQ,QAAQ,MAAM,QAAQ,IAAI;AAAG,YAAM,MAAI,IAAI,QAAQ,IAAI,IAAI,QAAQ,KAAI,MAAM,GAAE,EAAC,QAAO,QAAQ,QAAO,SAAQ,QAAQ,SAAuB,MAAK,CAAC,OAAM,MAAM,EAAE,SAAS,QAAQ,MAAM,IAAE,SAAU,KAAK,UAAU,QAAQ,IAAI,EAAC,CAAC;AAAE,YAAM,WAAS,MAAM,SAAS,QAAQ,KAAI,OAAO;AAAE,YAAM,OAAO,SAAS,MAAM;AAAE,eAAS,QAAQ,QAAQ,CAAC,OAAM,QAAM,MAAM,OAAO,KAAI,KAAK,CAAC;AAAE,aAAO,MAAM,KAAK,OAAO,KAAK,MAAM,SAAS,YAAY,CAAC,CAAC;AAAA,IAAE;AAAE,YAAQ,IAAI,SAAS,OAAO,WAAU,OAAO;AAAE,YAAQ,IAAI,GAAG,SAAS,OAAO,SAAS,MAAK,OAAO;AAAA,EAAE;AAAE;","names":[]}

package/dist/adapters/next.d.ts

@@ -0,0 +1,6 @@
+import { K as KabanosInstance } from '../core-C0gUmthe.js';
+import 'node:http';
+
+declare function createNextHandler(instance: KabanosInstance): (request: Request) => Promise<Response>;
+
+export { createNextHandler };

package/dist/adapters/next.js

@@ -0,0 +1,8 @@
+// src/adapters/next.ts
+function createNextHandler(instance) {
+  return (request) => instance.handler(request, request);
+}
+export {
+  createNextHandler
+};
+//# sourceMappingURL=next.js.map

package/dist/adapters/next.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/next.ts"],"sourcesContent":["import type { KabanosInstance } from '../core.js';\nexport function createNextHandler(instance:KabanosInstance){return (request:Request)=>instance.handler(request,request);}\n"],"mappings":";AACO,SAAS,kBAAkB,UAAyB;AAAC,SAAO,CAAC,YAAkB,SAAS,QAAQ,SAAQ,OAAO;AAAE;","names":[]}

package/dist/adapters/node.d.ts

@@ -0,0 +1,6 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { K as KabanosInstance } from '../core-C0gUmthe.js';
+
+declare function createNodeHandler(instance: KabanosInstance): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+
+export { createNodeHandler };

package/dist/adapters/node.js

@@ -0,0 +1,19 @@
+// src/adapters/node.ts
+import { Readable } from "stream";
+function createNodeHandler(instance) {
+  return async (req, res) => {
+    const forwarded = req.headers["x-forwarded-proto"];
+    const protocol = forwarded ? String(forwarded).split(",")[0].trim() : req.socket.encrypted ? "https" : "http";
+    const origin = `${protocol}://${req.headers.host ?? "localhost"}`;
+    const request = new Request(new URL(req.url ?? "/", origin), { method: req.method, headers: req.headers, body: ["GET", "HEAD"].includes(req.method ?? "GET") ? void 0 : Readable.toWeb(req), duplex: "half" });
+    const response = await instance.handler(request, req);
+    res.statusCode = response.status;
+    response.headers.forEach((value, key) => res.setHeader(key, value));
+    if (response.body) Readable.fromWeb(response.body).pipe(res);
+    else res.end();
+  };
+}
+export {
+  createNodeHandler
+};
+//# sourceMappingURL=node.js.map

package/dist/adapters/node.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/node.ts"],"sourcesContent":["import { Readable } from 'node:stream';\nimport type { IncomingMessage, ServerResponse } from 'node:http';\nimport type { KabanosInstance } from '../core.js';\n\nexport function createNodeHandler(instance:KabanosInstance){return async(req:IncomingMessage,res:ServerResponse)=>{\n  const forwarded=req.headers['x-forwarded-proto'];const protocol=forwarded?String(forwarded).split(',')[0]!.trim():(req.socket as {encrypted?:boolean}).encrypted?'https':'http';\n  const origin=`${protocol}://${req.headers.host??'localhost'}`;\n  const request=new Request(new URL(req.url??'/',origin),{method:req.method,headers:req.headers as HeadersInit,body:['GET','HEAD'].includes(req.method??'GET')?undefined:Readable.toWeb(req) as ReadableStream<Uint8Array>,duplex:'half'} as RequestInit);\n  const response=await instance.handler(request,req);res.statusCode=response.status;response.headers.forEach((value,key)=>res.setHeader(key,value));if(response.body)Readable.fromWeb(response.body as never).pipe(res);else res.end();\n};}\n"],"mappings":";AAAA,SAAS,gBAAgB;AAIlB,SAAS,kBAAkB,UAAyB;AAAC,SAAO,OAAM,KAAoB,QAAqB;AAChH,UAAM,YAAU,IAAI,QAAQ,mBAAmB;AAAE,UAAM,WAAS,YAAU,OAAO,SAAS,EAAE,MAAM,GAAG,EAAE,CAAC,EAAG,KAAK,IAAG,IAAI,OAAgC,YAAU,UAAQ;AACzK,UAAM,SAAO,GAAG,QAAQ,MAAM,IAAI,QAAQ,QAAM,WAAW;AAC3D,UAAM,UAAQ,IAAI,QAAQ,IAAI,IAAI,IAAI,OAAK,KAAI,MAAM,GAAE,EAAC,QAAO,IAAI,QAAO,SAAQ,IAAI,SAAuB,MAAK,CAAC,OAAM,MAAM,EAAE,SAAS,IAAI,UAAQ,KAAK,IAAE,SAAU,SAAS,MAAM,GAAG,GAAgC,QAAO,OAAM,CAAgB;AACtP,UAAM,WAAS,MAAM,SAAS,QAAQ,SAAQ,GAAG;AAAE,QAAI,aAAW,SAAS;AAAO,aAAS,QAAQ,QAAQ,CAAC,OAAM,QAAM,IAAI,UAAU,KAAI,KAAK,CAAC;AAAE,QAAG,SAAS,KAAK,UAAS,QAAQ,SAAS,IAAa,EAAE,KAAK,GAAG;AAAA,QAAO,KAAI,IAAI;AAAA,EACrO;AAAE;","names":[]}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { access, mkdir, writeFile } from "fs/promises";
+import path from "path";
+import prompts from "prompts";
+import pc from "picocolors";
+var command = process.argv[2];
+if (!command || ["-h", "--help", "help"].includes(command)) {
+  console.log(`kabanos
+
+Usage:
+  kabanos init   Create a configuration and print mount instructions
+  kabanos --help Show this help`);
+  process.exit(0);
+}
+if (command !== "init") {
+  console.error(pc.red(`Unknown command: ${command}`));
+  process.exit(1);
+}
+var root = process.cwd();
+var target = path.join(root, "kanban.config.ts");
+var exists = await fileExists(target);
+var answers = await prompts([
+  { type: "select", name: "framework", message: "Host framework", choices: [
+    { title: "Express", value: "express" },
+    { title: "Fastify", value: "fastify" },
+    { title: "Next.js route handler", value: "next" },
+    { title: "Node HTTP", value: "node" }
+  ] },
+  { type: "select", name: "storage", message: "Storage adapter", choices: [
+    { title: "SQLite (recommended)", value: "sqlite" },
+    { title: "PostgreSQL", value: "postgres" },
+    { title: "MySQL", value: "mysql" }
+  ] },
+  { type: "text", name: "mountPath", message: "Mount path", initial: "/admin/kb", validate: (value) => /^\/[\w/-]*$/.test(value) || "Enter an absolute URL path." },
+  { type: "confirm", name: "public", message: "Allow access without a host auth guard?", initial: false },
+  ...exists ? [{ type: "confirm", name: "overwrite", message: "kanban.config.ts exists. Replace it?", initial: false }] : []
+], { onCancel: () => {
+  console.log(pc.yellow("Initialization cancelled."));
+  process.exit(1);
+} });
+if (exists && !answers.overwrite) {
+  console.log(pc.yellow("No files changed."));
+  process.exit(0);
+}
+await mkdir(path.join(root, ".kanban"), { recursive: true });
+await writeFile(target, configTemplate(answers.storage, answers.mountPath, answers.public));
+console.log(pc.green("\nCreated kanban.config.ts and .kanban/"));
+console.log(pc.bold("\nMount Kabanos in your application:\n"));
+console.log(snippet(answers.framework, answers.mountPath));
+console.log(pc.dim("\nAdd .kanban/ to .gitignore. The initializer did not modify host source files."));
+async function fileExists(file) {
+  try {
+    await access(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function configTemplate(storage, mountPath, isPublic) {
+  return `import { defineConfig } from 'kabanos';
+
+export default defineConfig({
+  projectRoot: process.cwd(),
+  mountPath: ${JSON.stringify(mountPath)},
+  storage: {
+    adapter: '${storage}',${storage === "sqlite" ? "\n    filename: '.kanban/board.db'," : "\n    connectionString: process.env.KANBAN_DB_URL,"}
+  },
+  scan: {
+    include: ['src/**/*.{ts,tsx,js,jsx,py,go,rs,css,scss,html}'],
+    watch: process.env.NODE_ENV === 'development',
+  },
+  auth: {
+    enabled: ${!isPublic},${isPublic ? "" : "\n    // Replace this with your host application authorization check.\n    guard: (request) => Boolean(request.user),\n    actor: (request) => request.user ? { id: String(request.user.id), name: request.user.name } : undefined,"}
+  },
+});
+`;
+}
+function snippet(framework, mountPath) {
+  if (framework === "express") return `import config from './kanban.config.js';
+import { createKabanos } from 'kabanos';
+import { createExpressMiddleware } from 'kabanos/express';
+
+const kabanos = await createKabanos(config);
+app.use(${JSON.stringify(mountPath)}, createExpressMiddleware(kabanos));`;
+  if (framework === "fastify") return `import config from './kanban.config.js';
+import { createKabanos } from 'kabanos';
+import { kabanosFastify } from 'kabanos/fastify';
+
+const kabanos = await createKabanos(config);
+await app.register(kabanosFastify(kabanos));`;
+  if (framework === "next") return `// app/admin/kb/[[...kabanos]]/route.ts
+import config from '@/kanban.config';
+import { createKabanos } from 'kabanos';
+import { createNextHandler } from 'kabanos/next';
+
+const handler = createNextHandler(await createKabanos(config));
+export { handler as GET, handler as POST, handler as PATCH, handler as PUT };`;
+  return `import { createServer } from 'node:http';
+import config from './kanban.config.js';
+import { createKabanos } from 'kabanos';
+import { createNodeHandler } from 'kabanos/node';
+
+const kabanos = await createKabanos(config);
+createServer(createNodeHandler(kabanos)).listen(3000);`;
+}
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli.ts"],"sourcesContent":["import { access, mkdir, writeFile } from 'node:fs/promises';\nimport path from 'node:path';\nimport prompts from 'prompts';\nimport pc from 'picocolors';\n\nconst command = process.argv[2];\nif (!command || ['-h', '--help', 'help'].includes(command)) {\n  console.log(`kabanos\\n\\nUsage:\\n  kabanos init   Create a configuration and print mount instructions\\n  kabanos --help Show this help`);\n  process.exit(0);\n}\nif (command !== 'init') { console.error(pc.red(`Unknown command: ${command}`)); process.exit(1); }\n\nconst root = process.cwd();\nconst target = path.join(root, 'kanban.config.ts');\nconst exists = await fileExists(target);\nconst answers = await prompts([\n  { type: 'select', name: 'framework', message: 'Host framework', choices: [\n    { title: 'Express', value: 'express' }, { title: 'Fastify', value: 'fastify' }, { title: 'Next.js route handler', value: 'next' }, { title: 'Node HTTP', value: 'node' },\n  ] },\n  { type: 'select', name: 'storage', message: 'Storage adapter', choices: [\n    { title: 'SQLite (recommended)', value: 'sqlite' }, { title: 'PostgreSQL', value: 'postgres' }, { title: 'MySQL', value: 'mysql' },\n  ] },\n  { type: 'text', name: 'mountPath', message: 'Mount path', initial: '/admin/kb', validate: value => /^\\/[\\w/-]*$/.test(value) || 'Enter an absolute URL path.' },\n  { type: 'confirm', name: 'public', message: 'Allow access without a host auth guard?', initial: false },\n  ...(exists ? [{ type: 'confirm' as const, name: 'overwrite', message: 'kanban.config.ts exists. Replace it?', initial: false }] : []),\n], { onCancel: () => { console.log(pc.yellow('Initialization cancelled.')); process.exit(1); } });\n\nif (exists && !answers.overwrite) { console.log(pc.yellow('No files changed.')); process.exit(0); }\nawait mkdir(path.join(root, '.kanban'), { recursive: true });\nawait writeFile(target, configTemplate(answers.storage, answers.mountPath, answers.public));\nconsole.log(pc.green('\\nCreated kanban.config.ts and .kanban/'));\nconsole.log(pc.bold('\\nMount Kabanos in your application:\\n'));\nconsole.log(snippet(answers.framework, answers.mountPath));\nconsole.log(pc.dim('\\nAdd .kanban/ to .gitignore. The initializer did not modify host source files.'));\n\nasync function fileExists(file:string){try{await access(file);return true;}catch{return false;}}\nfunction configTemplate(storage:string,mountPath:string,isPublic:boolean){return `import { defineConfig } from 'kabanos';\\n\\nexport default defineConfig({\\n  projectRoot: process.cwd(),\\n  mountPath: ${JSON.stringify(mountPath)},\\n  storage: {\\n    adapter: '${storage}',${storage==='sqlite'?\"\\n    filename: '.kanban/board.db',\":\"\\n    connectionString: process.env.KANBAN_DB_URL,\"}\\n  },\\n  scan: {\\n    include: ['src/**/*.{ts,tsx,js,jsx,py,go,rs,css,scss,html}'],\\n    watch: process.env.NODE_ENV === 'development',\\n  },\\n  auth: {\\n    enabled: ${!isPublic},${isPublic?'':'\\n    // Replace this with your host application authorization check.\\n    guard: (request) => Boolean(request.user),\\n    actor: (request) => request.user ? { id: String(request.user.id), name: request.user.name } : undefined,'}\\n  },\\n});\\n`;}\nfunction snippet(framework:string,mountPath:string){\n  if(framework==='express')return `import config from './kanban.config.js';\\nimport { createKabanos } from 'kabanos';\\nimport { createExpressMiddleware } from 'kabanos/express';\\n\\nconst kabanos = await createKabanos(config);\\napp.use(${JSON.stringify(mountPath)}, createExpressMiddleware(kabanos));`;\n  if(framework==='fastify')return `import config from './kanban.config.js';\\nimport { createKabanos } from 'kabanos';\\nimport { kabanosFastify } from 'kabanos/fastify';\\n\\nconst kabanos = await createKabanos(config);\\nawait app.register(kabanosFastify(kabanos));`;\n  if(framework==='next')return `// app/admin/kb/[[...kabanos]]/route.ts\\nimport config from '@/kanban.config';\\nimport { createKabanos } from 'kabanos';\\nimport { createNextHandler } from 'kabanos/next';\\n\\nconst handler = createNextHandler(await createKabanos(config));\\nexport { handler as GET, handler as POST, handler as PATCH, handler as PUT };`;\n  return `import { createServer } from 'node:http';\\nimport config from './kanban.config.js';\\nimport { createKabanos } from 'kabanos';\\nimport { createNodeHandler } from 'kabanos/node';\\n\\nconst kabanos = await createKabanos(config);\\ncreateServer(createNodeHandler(kabanos)).listen(3000);`;\n}\n"],"mappings":"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","names":[]}

package/dist/core-C0gUmthe.d.ts

@@ -0,0 +1,156 @@
+import { IncomingMessage } from 'node:http';
+
+type ThemeMode = 'light' | 'dark' | 'system';
+type Actor = {
+    id: string;
+    name?: string;
+};
+type CardStatus = 'open' | 'resolved' | 'archived' | 'changed' | 'orphaned';
+interface ColumnConfig {
+    id: string;
+    name: string;
+    completion?: boolean;
+    colorToken?: string;
+}
+interface TagConfig {
+    column: string;
+    priority?: 'low' | 'normal' | 'high';
+    label?: string;
+}
+interface ThemeTokens {
+    canvas: string;
+    canvasSoft: string;
+    surface: string;
+    ink: string;
+    inkMuted: string;
+    hairline: string;
+    primary: string;
+    primaryActive: string;
+}
+interface AuthConfig<T = any> {
+    enabled?: boolean;
+    guard?: (request: T) => boolean | Promise<boolean>;
+    actor?: (request: T) => Actor | undefined | Promise<Actor | undefined>;
+}
+interface StorageConfig {
+    adapter?: 'sqlite' | 'postgres' | 'mysql';
+    connectionString?: string;
+    filename?: string;
+}
+interface ScanConfig {
+    include?: string[];
+    exclude?: string[];
+    tags?: Record<string, TagConfig>;
+    watch?: boolean;
+    intervalMs?: number;
+    maxFileSize?: number;
+    parsers?: CommentParser[];
+}
+interface CommentParser {
+    extensions: string[];
+    parse(filePath: string, source: string, tags: string[]): SourceComment[];
+}
+interface KanbanConfig<TRequest = any> {
+    projectRoot?: string;
+    mountPath?: string;
+    boardName?: string;
+    columns?: Array<string | ColumnConfig>;
+    scan?: ScanConfig;
+    storage?: StorageConfig;
+    theme?: {
+        default?: ThemeMode;
+        overrides?: Partial<ThemeTokens>;
+    };
+    auth?: AuthConfig<TRequest>;
+}
+interface SourceComment {
+    filePath: string;
+    line: number;
+    endLine: number;
+    tag: string;
+    text: string;
+    rawText: string;
+    contentHash: string;
+    contextHash: string;
+    occurrence: number;
+}
+interface Card {
+    id: string;
+    columnId: string;
+    position: number;
+    tag: string;
+    title: string;
+    body: string;
+    notes: string;
+    assignee?: string;
+    labels: string[];
+    priority: string;
+    sourceFilePath: string;
+    sourceLine: number;
+    sourceContentHash: string;
+    sourceContextHash: string;
+    sourceOccurrence: number;
+    status: CardStatus;
+    createdAt: string;
+    updatedAt: string;
+}
+interface BoardState {
+    id: string;
+    name: string;
+    columns: Array<ColumnConfig & {
+        position: number;
+    }>;
+    cards: Card[];
+    settings: Record<string, unknown>;
+}
+type NodeRequest = IncomingMessage;
+interface StorageAdapter {
+    migrate(): Promise<void>;
+    initialize(config: ResolvedKanbanConfig): Promise<void>;
+    getBoard(): Promise<BoardState>;
+    reconcile(comments: SourceComment[]): Promise<{
+        created: number;
+        updated: number;
+        archived: number;
+    }>;
+    moveCard(id: string, columnId: string, position: number, actor?: Actor): Promise<void>;
+    updateCard(id: string, patch: {
+        notes?: string;
+        assignee?: string | null;
+        labels?: string[];
+    }, actor?: Actor): Promise<void>;
+    getActivity(cardId: string): Promise<unknown[]>;
+    updateSettings(patch: Record<string, unknown>): Promise<void>;
+    replaceColumns(columns: ColumnConfig[], destinationColumnId?: string): Promise<void>;
+    close(): Promise<void>;
+}
+interface ResolvedKanbanConfig extends Required<Omit<KanbanConfig, 'auth' | 'theme' | 'storage' | 'scan' | 'columns'>> {
+    columns: ColumnConfig[];
+    scan: Required<Omit<ScanConfig, 'parsers'>> & {
+        parsers: CommentParser[];
+    };
+    storage: Required<StorageConfig>;
+    theme: {
+        default: ThemeMode;
+        overrides: Partial<ThemeTokens>;
+    };
+    auth: AuthConfig;
+}
+
+declare function defineConfig<T = any>(config: KanbanConfig<T>): KanbanConfig<T>;
+declare function resolveConfig(input?: KanbanConfig): ResolvedKanbanConfig;
+
+interface KabanosInstance {
+    config: ReturnType<typeof resolveConfig>;
+    storage: StorageAdapter;
+    handler(request: Request, nativeRequest?: unknown): Promise<Response>;
+    scan(): Promise<{
+        created: number;
+        updated: number;
+        archived: number;
+    }>;
+    close(): Promise<void>;
+}
+declare function createKabanos<TRequest = any>(input: KanbanConfig<TRequest>): Promise<KabanosInstance>;
+
+export { type Actor as A, type BoardState as B, type ColumnConfig as C, type KabanosInstance as K, type NodeRequest as N, type ResolvedKanbanConfig as R, type SourceComment as S, type TagConfig as T, type StorageAdapter as a, type AuthConfig as b, type Card as c, type CardStatus as d, type CommentParser as e, type KanbanConfig as f, type ScanConfig as g, type StorageConfig as h, type ThemeMode as i, type ThemeTokens as j, createKabanos as k, defineConfig as l, resolveConfig as r };