@teknologika/chisel-knowledge-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bruce McLeod
+
+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,68 @@
+# chisel-knowledge-mcp
+
+Standalone MCP server and library for building and managing knowledge workspaces.
+
+Canonical behavior documentation lives in [docs/chisel-knowledge-mcp.md](./docs/chisel-knowledge-mcp.md).
+
+## Requirements
+
+- Node.js 22 or newer
+- `npm`
+
+## Install
+
+```bash
+npm install
+```
+
+## Library usage
+
+Import the workspace service and related types directly from the package root:
+
+```ts
+import { WorkspaceService, KnowledgeIndex } from '@teknologika/chisel-knowledge-mcp';
+```
+
+The MCP server remains available from the `server` subpath and through the published binary.
+
+## Build
+
+```bash
+npm run build
+```
+
+## Type check
+
+```bash
+npx tsc --noEmit
+```
+
+## Config
+
+The server reads workspace configuration from:
+
+`~/.chisel/config.json`
+
+If the file does not exist, the server starts with zero configured workspaces and logs a warning to stderr. See [config.example.json](./config.example.json) for the expected shape.
+
+## Claude Desktop
+
+Use this MCP server with Claude Desktop by adding:
+
+```json
+{
+  "mcpServers": {
+    "chisel-knowledge": {
+      "command": "npx",
+      "args": ["-y", "@teknologika/chisel-knowledge-mcp"]
+    }
+  }
+}
+```
+
+## Notes
+
+- Transport is stdio only.
+- Logging goes to stderr so stdout stays reserved for MCP protocol messages.
+- The binary is `chisel-knowledge-mcp`.
+- The package root exports the library surface; `@teknologika/chisel-knowledge-mcp/server` resolves to the MCP server entry point.

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const bunBinary = process.env.BUN ?? 'bun';
+const serverPath = resolve(dirname(fileURLToPath(import.meta.url)), 'server.js');
+const result = spawnSync(bunBinary, [serverPath, ...process.argv.slice(2)], {
+    stdio: 'inherit',
+});
+if (result.error) {
+    const message = result.error instanceof Error ? result.error.message : String(result.error);
+    process.stderr.write(`Failed to start Bun CLI launcher (${bunBinary}): ${message}\n`);
+    process.exit(1);
+}
+process.exit(typeof result.status === 'number' ? result.status : 1);

package/dist/domains/workspace/index.d.ts

@@ -0,0 +1,3 @@
+export * from './workspace.service.js';
+export * from './workspace.types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/domains/workspace/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/domains/workspace/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC"}

package/dist/domains/workspace/index.js

@@ -0,0 +1,2 @@
+export * from './workspace.service.js';
+export * from './workspace.types.js';

package/dist/domains/workspace/knowledge-index.d.ts

@@ -0,0 +1,12 @@
+import type { SearchResults } from './workspace.types.js';
+export declare class KnowledgeIndex {
+    private readonly workspacePath;
+    private readonly db;
+    constructor(workspacePath: string);
+    indexFile(absPath: string): void;
+    removeFile(absPath: string): void;
+    search(query: string, limit?: number): SearchResults;
+    close(): void;
+    private withTransaction;
+}
+//# sourceMappingURL=knowledge-index.d.ts.map

package/dist/domains/workspace/knowledge-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-index.d.ts","sourceRoot":"","sources":["../../../src/domains/workspace/knowledge-index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AA8B1D,qBAAa,cAAc;IAGb,OAAO,CAAC,QAAQ,CAAC,aAAa;IAF1C,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAW;gBAED,aAAa,EAAE,MAAM;IAOlD,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAwBhC,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAKjC,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,aAAa;IA6BhD,KAAK,IAAI,IAAI;IAIb,OAAO,CAAC,eAAe;CAGxB"}

package/dist/domains/workspace/knowledge-index.js

@@ -0,0 +1,151 @@
+import { readFileSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+const SCHEMA = `
+  CREATE TABLE IF NOT EXISTS chunks (
+    id       INTEGER PRIMARY KEY,
+    path     TEXT NOT NULL,
+    heading  TEXT,
+    body     TEXT NOT NULL,
+    mtime    INTEGER NOT NULL
+  );
+  CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+    path, heading, body,
+    content='chunks', content_rowid='id'
+  );
+  CREATE TRIGGER IF NOT EXISTS chunks_ai AFTER INSERT ON chunks BEGIN
+    INSERT INTO chunks_fts(rowid, path, heading, body)
+    VALUES (new.id, new.path, new.heading, new.body);
+  END;
+  CREATE TRIGGER IF NOT EXISTS chunks_ad AFTER DELETE ON chunks BEGIN
+    INSERT INTO chunks_fts(chunks_fts, rowid, path, heading, body)
+    VALUES ('delete', old.id, old.path, old.heading, old.body);
+  END;
+  CREATE TRIGGER IF NOT EXISTS chunks_au AFTER UPDATE ON chunks BEGIN
+    INSERT INTO chunks_fts(chunks_fts, rowid, path, heading, body)
+    VALUES ('delete', old.id, old.path, old.heading, old.body);
+    INSERT INTO chunks_fts(rowid, path, heading, body)
+    VALUES (new.id, new.path, new.heading, new.body);
+  END;
+`;
+export class KnowledgeIndex {
+    workspacePath;
+    db;
+    constructor(workspacePath) {
+        this.workspacePath = workspacePath;
+        const dbPath = join(workspacePath, '.knowledge-index.db');
+        this.db = new DatabaseSync(dbPath);
+        this.db.exec('PRAGMA journal_mode = WAL');
+        this.db.exec(SCHEMA);
+    }
+    indexFile(absPath) {
+        const path = relative(this.workspacePath, absPath);
+        const mtime = statSync(absPath).mtimeMs;
+        const existing = this.db
+            .prepare('SELECT mtime FROM chunks WHERE path = ? LIMIT 1')
+            .get(path);
+        if (existing && existing.mtime === mtime)
+            return;
+        this.db.prepare('DELETE FROM chunks WHERE path = ?').run(path);
+        const raw = readFileSync(absPath, 'utf8');
+        const chunks = chunkMarkdown(raw);
+        const insert = this.db.prepare('INSERT INTO chunks (path, heading, body, mtime) VALUES (?, ?, ?, ?)');
+        this.db.exec('BEGIN');
+        try {
+            for (const chunk of chunks) {
+                insert.run(path, chunk.heading ?? null, chunk.body, mtime);
+            }
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    removeFile(absPath) {
+        const path = relative(this.workspacePath, absPath);
+        this.db.prepare('DELETE FROM chunks WHERE path = ?').run(path);
+    }
+    search(query, limit = 10) {
+        const normalized = normalizeFtsQuery(query);
+        if (!normalized)
+            return { results: [] };
+        const rows = this.db
+            .prepare(`
+        SELECT c.path, c.heading,
+               snippet(chunks_fts, 2, '[', ']', '...', 16) AS excerpt
+        FROM chunks_fts f
+        JOIN chunks c ON c.id = f.rowid
+        WHERE chunks_fts MATCH ?
+        ORDER BY bm25(chunks_fts)
+        LIMIT ?
+      `)
+            .all(normalized, limit);
+        return {
+            results: rows.map((row, index) => ({
+                file: row.path,
+                excerpt: row.heading ? `**${row.heading}**\n${row.excerpt}` : row.excerpt,
+                score: 1 - index / Math.max(rows.length, 1),
+            })),
+        };
+    }
+    close() {
+        this.db.close();
+    }
+}
+function chunkMarkdown(content) {
+    const stripped = content.replace(/^---[\s\S]*?---\n?/, '');
+    const cleaned = stripped
+        .replace(/!\[([^\]]*)\]\([^)]*\)/g, '$1')
+        .replace(/<!--[\s\S]*?-->/g, '')
+        .trim();
+    const lines = cleaned.split('\n');
+    const chunks = [];
+    let currentHeading = null;
+    let currentLines = [];
+    const flush = () => {
+        const body = currentLines.join('\n').trim();
+        if (!body)
+            return;
+        if (body.length > 1500) {
+            const paragraphs = body.split(/\n{2,}/);
+            let acc = '';
+            for (const para of paragraphs) {
+                if (acc.length + para.length > 1500 && acc.length > 0) {
+                    chunks.push({ heading: currentHeading, body: acc.trim() });
+                    acc = para;
+                }
+                else {
+                    acc = acc ? `${acc}\n\n${para}` : para;
+                }
+            }
+            if (acc.trim())
+                chunks.push({ heading: currentHeading, body: acc.trim() });
+        }
+        else {
+            chunks.push({ heading: currentHeading, body });
+        }
+        currentLines = [];
+    };
+    for (const line of lines) {
+        const headingMatch = /^(#{1,3})\s+(.+)/.exec(line);
+        if (headingMatch) {
+            flush();
+            currentHeading = headingMatch[2].trim();
+        }
+        else {
+            currentLines.push(line);
+        }
+    }
+    flush();
+    return chunks;
+}
+function normalizeFtsQuery(query) {
+    return query
+        .trim()
+        .split(/\s+/)
+        .map((token) => token.replace(/[^a-zA-Z0-9_]/g, ''))
+        .filter((token) => token.length > 0)
+        .map((token) => `${token}*`)
+        .join(' ');
+}

package/dist/domains/workspace/workspace.service.d.ts

@@ -0,0 +1,21 @@
+import type { ArchiveResult, ConfigFile, IngestResult, InboxListResult, KnowledgeListResult, ReadResult, SearchResults, WorkspaceConfig, WorkspaceListing, WorkspaceStatus, WriteResult } from './workspace.types.js';
+export declare class WorkspaceService {
+    private readonly config;
+    constructor(config?: ConfigFile);
+    getConfig(): ConfigFile;
+    resolve(name: string): WorkspaceConfig;
+    listWorkspaces(): WorkspaceListing[];
+    status(name: string): WorkspaceStatus;
+    ingestText(name: string, content: string, title?: string): IngestResult;
+    ingestClipboard(name: string, title?: string): IngestResult;
+    ingestUrl(name: string, url: string, title?: string): Promise<IngestResult>;
+    search(name: string, query: string, limit?: number): SearchResults;
+    read(name: string, pathName: string): ReadResult;
+    list(name: string, directory?: string): KnowledgeListResult;
+    listInbox(name: string): InboxListResult;
+    write(name: string, pathName: string, content: string): WriteResult;
+    archive(name: string, file: string): ArchiveResult;
+    private collectMarkdownFiles;
+    private writeInboxMarkdown;
+}
+//# sourceMappingURL=workspace.service.d.ts.map

package/dist/domains/workspace/workspace.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.service.d.ts","sourceRoot":"","sources":["../../../src/domains/workspace/workspace.service.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,aAAa,EACb,UAAU,EACV,YAAY,EACZ,eAAe,EAEf,mBAAmB,EACnB,UAAU,EACV,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,WAAW,EACZ,MAAM,sBAAsB,CAAC;AAI9B,qBAAa,gBAAgB;IACf,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,GAAE,UAAyB;IAE9D,SAAS,IAAI,UAAU;IAIvB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe;IAUtC,cAAc,IAAI,gBAAgB,EAAE;IAOpC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe;IAkCrC,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,YAAY;IAMvE,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,YAAY;IAOrD,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IA0CjF,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,aAAa;IAsB9D,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU;IAWhD,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,mBAAmB;IAe3D,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe;IAexC,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,WAAW;IAYnE,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,aAAa;IA0BlD,OAAO,CAAC,oBAAoB;IAmC5B,OAAO,CAAC,kBAAkB;CAY3B"}

package/dist/domains/workspace/workspace.service.js

@@ -0,0 +1,198 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, writeFileSync } from 'node:fs';
+import { basename, dirname, resolve, join, relative } from 'node:path';
+import { execSync } from 'node:child_process';
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
+import { KnowledgeIndex } from './knowledge-index.js';
+import { loadConfig } from '../../shared/config/index.js';
+export class WorkspaceService {
+    config;
+    constructor(config = loadConfig()) {
+        this.config = config;
+    }
+    getConfig() {
+        return this.config;
+    }
+    resolve(name) {
+        const workspace = this.config.workspaces.find((entry) => entry.name === name);
+        if (!workspace) {
+            throw new McpError(ErrorCode.InvalidParams, `Unknown workspace: ${name}`);
+        }
+        return workspace;
+    }
+    listWorkspaces() {
+        return this.config.workspaces.map((workspace) => ({
+            ...workspace,
+            exists: existsSync(workspace.path),
+        }));
+    }
+    status(name) {
+        const workspace = this.resolve(name);
+        const exists = existsSync(workspace.path);
+        return {
+            ...workspace,
+            exists,
+            inboxCount: 0,
+            knowledgeCount: 0,
+            lastCompiled: null,
+        };
+    }
+    ingestText(name, content, title) {
+        const workspace = this.resolve(name);
+        const inboxPath = join(workspace.path, 'inbox');
+        mkdirSync(inboxPath, { recursive: true });
+        const filePath = join(inboxPath, `${currentDateStamp()}-${slugify(title)}.md`);
+        writeFileSync(filePath, content, 'utf8');
+        return {
+            file: relative(workspace.path, filePath),
+            workspace: workspace.name,
+        };
+    }
+    ingestClipboard(name, title) {
+        const clipboard = execSync('pbpaste', { encoding: 'utf8' });
+        return this.ingestText(name, clipboard, title);
+    }
+    async ingestUrl(name, url, title) {
+        const jinaUrl = `https://r.jina.ai/${url}`;
+        let response;
+        try {
+            response = await fetch(jinaUrl, {
+                headers: { Accept: 'text/markdown' },
+            });
+        }
+        catch (err) {
+            throw new McpError(ErrorCode.InternalError, `Failed to fetch URL: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        if (!response.ok) {
+            throw new McpError(ErrorCode.InternalError, `Jina Reader returned ${response.status} for ${url}`);
+        }
+        const content = await response.text();
+        const resolvedTitle = title ?? extractJinaTitle(content) ?? url;
+        return this.ingestText(name, content, resolvedTitle);
+    }
+    search(name, query, limit = 10) {
+        const workspace = this.resolve(name);
+        const knowledgeRoot = join(workspace.path, 'knowledge');
+        if (!existsSync(knowledgeRoot)) {
+            return { results: [] };
+        }
+        const index = new KnowledgeIndex(workspace.path);
+        try {
+            const files = this.collectMarkdownFiles(workspace.path, knowledgeRoot);
+            for (const file of files) {
+                index.indexFile(join(workspace.path, file.path));
+            }
+            return index.search(query, limit);
+        }
+        finally {
+            index.close();
+        }
+    }
+    read(name, pathName) {
+        const workspace = this.resolve(name);
+        const filePath = resolve(workspace.path, pathName);
+        const content = readFileSync(filePath, 'utf8');
+        return {
+            content,
+            file: relative(workspace.path, filePath),
+        };
+    }
+    list(name, directory) {
+        const workspace = this.resolve(name);
+        const knowledgeRoot = directory ? resolve(workspace.path, directory) : join(workspace.path, 'knowledge');
+        if (!existsSync(knowledgeRoot)) {
+            return { files: [] };
+        }
+        const files = this.collectMarkdownFiles(workspace.path, knowledgeRoot);
+        return {
+            files,
+        };
+    }
+    listInbox(name) {
+        const workspace = this.resolve(name);
+        const inboxRoot = join(workspace.path, 'inbox');
+        if (!existsSync(inboxRoot)) {
+            return { files: [] };
+        }
+        const files = this.collectMarkdownFiles(workspace.path, inboxRoot, ['archived']);
+        return {
+            files,
+        };
+    }
+    write(name, pathName, content) {
+        const workspace = this.resolve(name);
+        const target = join(workspace.path, 'knowledge', pathName);
+        mkdirSync(dirname(target), { recursive: true });
+        writeFileSync(target, content, 'utf8');
+        return {
+            file: relative(workspace.path, target),
+            workspace: name,
+        };
+    }
+    archive(name, file) {
+        const workspace = this.resolve(name);
+        const source = join(workspace.path, file);
+        if (!existsSync(source)) {
+            throw new McpError(ErrorCode.InvalidParams, `File not found: ${file}`);
+        }
+        const archivedDir = join(workspace.path, 'inbox', 'archived');
+        mkdirSync(archivedDir, { recursive: true });
+        let destination = join(archivedDir, basename(source));
+        if (existsSync(destination)) {
+            destination = join(archivedDir, `${Date.now()}-${basename(source)}`);
+        }
+        renameSync(source, destination);
+        return {
+            original: relative(workspace.path, source),
+            archived: relative(workspace.path, destination),
+            workspace: name,
+        };
+    }
+    collectMarkdownFiles(workspaceRoot, directory, excludedDirectories = []) {
+        const entries = readdirSync(directory, { withFileTypes: true });
+        const files = [];
+        for (const entry of entries) {
+            const entryPath = join(directory, entry.name);
+            if (entry.isDirectory()) {
+                if (excludedDirectories.includes(entry.name)) {
+                    continue;
+                }
+                files.push(...this.collectMarkdownFiles(workspaceRoot, entryPath, excludedDirectories));
+                continue;
+            }
+            if (!entry.name.endsWith('.md')) {
+                continue;
+            }
+            const stats = statSync(entryPath);
+            files.push({
+                path: relative(workspaceRoot, entryPath),
+                size: stats.size,
+                modified: stats.mtime.toISOString(),
+            });
+        }
+        return files.sort((left, right) => left.path.localeCompare(right.path));
+    }
+}
+function currentDateStamp(date = new Date()) {
+    const parts = new Intl.DateTimeFormat('en-CA', {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+    }).formatToParts(date);
+    const byType = new Map(parts.map((part) => [part.type, part.value]));
+    return `${byType.get('year')}-${byType.get('month')}-${byType.get('day')}`;
+}
+function slugify(title) {
+    const raw = (title ?? 'untitled').toLowerCase();
+    const slug = raw
+        .replace(/[^a-z0-9\s-]/g, '')
+        .trim()
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 50);
+    return slug || 'untitled';
+}
+function extractJinaTitle(content) {
+    const match = /^Title:\s*(.+)$/m.exec(content);
+    return match ? match[1].trim() : null;
+}

package/dist/domains/workspace/workspace.types.d.ts

@@ -0,0 +1,59 @@
+export type WorkspaceConfig = {
+    name: string;
+    path: string;
+};
+export type ConfigFile = {
+    workspaces: WorkspaceConfig[];
+};
+export type WorkspaceListing = WorkspaceConfig & {
+    exists: boolean;
+};
+export type WorkspaceStatus = WorkspaceListing & {
+    inboxCount: number;
+    knowledgeCount: number;
+    lastCompiled: string | null;
+};
+export type IngestResult = {
+    file: string;
+    workspace: string;
+    imagesLocalised?: number;
+    imagesFailed?: number;
+};
+export type InboxFile = {
+    path: string;
+    size: number;
+    modified: string;
+};
+export type InboxListResult = {
+    files: InboxFile[];
+};
+export type ReadResult = {
+    content: string;
+    file: string;
+};
+export type WriteResult = {
+    file: string;
+    workspace: string;
+};
+export type ArchiveResult = {
+    original: string;
+    archived: string;
+    workspace: string;
+};
+export type KnowledgeFile = {
+    path: string;
+    size: number;
+    modified: string;
+};
+export type KnowledgeListResult = {
+    files: KnowledgeFile[];
+};
+export type SearchResult = {
+    file: string;
+    excerpt: string;
+    score: number;
+};
+export type SearchResults = {
+    results: SearchResult[];
+};
+//# sourceMappingURL=workspace.types.d.ts.map

package/dist/domains/workspace/workspace.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.types.d.ts","sourceRoot":"","sources":["../../../src/domains/workspace/workspace.types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,UAAU,EAAE,eAAe,EAAE,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,eAAe,GAAG;IAC/C,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,gBAAgB,GAAG;IAC/C,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,SAAS,EAAE,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,aAAa,EAAE,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,YAAY,EAAE,CAAC;CACzB,CAAC"}

package/dist/domains/workspace/workspace.types.js

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

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { WorkspaceService } from './domains/workspace/workspace.service.js';
+export { KnowledgeIndex } from './domains/workspace/knowledge-index.js';
+export type { WorkspaceConfig, ConfigFile, WorkspaceListing, WorkspaceStatus, IngestResult, InboxFile, InboxListResult, ReadResult, WriteResult, ArchiveResult, KnowledgeFile, KnowledgeListResult, SearchResult, SearchResults, } from './domains/workspace/workspace.types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAC5E,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AACxE,YAAY,EACV,eAAe,EACf,UAAU,EACV,gBAAgB,EAChB,eAAe,EACf,YAAY,EACZ,SAAS,EACT,eAAe,EACf,UAAU,EACV,WAAW,EACX,aAAa,EACb,aAAa,EACb,mBAAmB,EACnB,YAAY,EACZ,aAAa,GACd,MAAM,wCAAwC,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+// Library entry point — exports the service layer for direct use in Chisel
+// and other consumers without requiring the MCP protocol.
+export { WorkspaceService } from './domains/workspace/workspace.service.js';
+export { KnowledgeIndex } from './domains/workspace/knowledge-index.js';

package/dist/infrastructure/mcp/index.d.ts

@@ -0,0 +1,3 @@
+export * from './mcp-server.js';
+export * from './tool-schemas.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/infrastructure/mcp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/mcp/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC"}

package/dist/infrastructure/mcp/index.js

@@ -0,0 +1,2 @@
+export * from './mcp-server.js';
+export * from './tool-schemas.js';

package/dist/infrastructure/mcp/mcp-server.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createMcpServer(): McpServer;
+export declare function startMcpServer(): Promise<void>;
+//# sourceMappingURL=mcp-server.d.ts.map

package/dist/infrastructure/mcp/mcp-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/mcp/mcp-server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA4BpE,wBAAgB,eAAe,IAAI,SAAS,CAqF3C;AAED,wBAAsB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAIpD"}

package/dist/infrastructure/mcp/mcp-server.js

@@ -0,0 +1,38 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { WorkspaceService } from '../../domains/workspace/index.js';
+import { KnowledgeArchiveSchema, KnowledgeIngestClipboardSchema, KnowledgeIngestTextSchema, KnowledgeIngestUrlSchema, KnowledgeListInboxSchema, KnowledgeListSchema, KnowledgeListWorkspacesSchema, KnowledgeReadSchema, KnowledgeSearchSchema, KnowledgeWorkspaceStatusSchema, KnowledgeWriteSchema, } from './tool-schemas.js';
+function textContent(value) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(value, null, 2),
+            },
+        ],
+    };
+}
+export function createMcpServer() {
+    const service = new WorkspaceService();
+    const server = new McpServer({
+        name: 'chisel-knowledge-mcp',
+        version: '0.1.0',
+    });
+    server.tool('knowledge_list_workspaces', 'List configured workspaces.', KnowledgeListWorkspacesSchema, async () => textContent(service.listWorkspaces()));
+    server.tool('knowledge_workspace_status', 'Inspect a workspace.', KnowledgeWorkspaceStatusSchema, async ({ workspace }) => textContent(service.status(workspace)));
+    server.tool('knowledge_ingest_text', 'Write raw text into a workspace inbox.', KnowledgeIngestTextSchema, async ({ workspace, content, title }) => textContent(service.ingestText(workspace, content, title)));
+    server.tool('knowledge_ingest_clipboard', 'Read clipboard text and write it into a workspace inbox.', KnowledgeIngestClipboardSchema, async ({ workspace, title }) => textContent(service.ingestClipboard(workspace, title)));
+    server.tool('knowledge_ingest_url', 'Ingest a URL into a workspace inbox.', KnowledgeIngestUrlSchema, async ({ workspace, url, title }) => textContent(await service.ingestUrl(workspace, url, title)));
+    server.tool('knowledge_search', 'Search workspace knowledge.', KnowledgeSearchSchema, async ({ workspace, query, limit }) => textContent(service.search(workspace, query, limit)));
+    server.tool('knowledge_list_inbox', 'List uncompiled files in a workspace inbox.', KnowledgeListInboxSchema, async ({ workspace }) => textContent(service.listInbox(workspace)));
+    server.tool('knowledge_write', 'Write a compiled article into the workspace knowledge directory.', KnowledgeWriteSchema, async ({ workspace, path, content }) => textContent(service.write(workspace, path, content)));
+    server.tool('knowledge_archive', 'Move a processed inbox file to inbox/archived/.', KnowledgeArchiveSchema, async ({ workspace, file }) => textContent(service.archive(workspace, file)));
+    server.tool('knowledge_read', 'Read a knowledge file from a workspace.', KnowledgeReadSchema, async ({ workspace, path }) => textContent(service.read(workspace, path)));
+    server.tool('knowledge_list', 'List markdown files in a workspace knowledge directory.', KnowledgeListSchema, async ({ workspace, directory }) => textContent(service.list(workspace, directory)));
+    return server;
+}
+export async function startMcpServer() {
+    const server = createMcpServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/dist/infrastructure/mcp/tool-schemas.d.ts

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+export declare const KnowledgeListWorkspacesSchema: {};
+export declare const KnowledgeWorkspaceStatusSchema: {
+    workspace: z.ZodString;
+};
+export declare const KnowledgeIngestTextSchema: {
+    workspace: z.ZodString;
+    content: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+};
+export declare const KnowledgeIngestClipboardSchema: {
+    workspace: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+};
+export declare const KnowledgeIngestUrlSchema: {
+    workspace: z.ZodString;
+    url: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+};
+export declare const KnowledgeSearchSchema: {
+    workspace: z.ZodString;
+    query: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+};
+export declare const KnowledgeListInboxSchema: {
+    workspace: z.ZodString;
+};
+export declare const KnowledgeWriteSchema: {
+    workspace: z.ZodString;
+    path: z.ZodString;
+    content: z.ZodString;
+};
+export declare const KnowledgeArchiveSchema: {
+    workspace: z.ZodString;
+    file: z.ZodString;
+};
+export declare const KnowledgeReadSchema: {
+    workspace: z.ZodString;
+    path: z.ZodString;
+};
+export declare const KnowledgeListSchema: {
+    workspace: z.ZodString;
+    directory: z.ZodOptional<z.ZodString>;
+};
+export declare const ToolSchemas: {
+    readonly knowledge_list_workspaces: {};
+    readonly knowledge_workspace_status: {
+        workspace: z.ZodString;
+    };
+    readonly knowledge_ingest_text: {
+        workspace: z.ZodString;
+        content: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    };
+    readonly knowledge_ingest_clipboard: {
+        workspace: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    };
+    readonly knowledge_ingest_url: {
+        workspace: z.ZodString;
+        url: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    };
+    readonly knowledge_search: {
+        workspace: z.ZodString;
+        query: z.ZodString;
+        limit: z.ZodOptional<z.ZodNumber>;
+    };
+    readonly knowledge_list_inbox: {
+        workspace: z.ZodString;
+    };
+    readonly knowledge_write: {
+        workspace: z.ZodString;
+        path: z.ZodString;
+        content: z.ZodString;
+    };
+    readonly knowledge_archive: {
+        workspace: z.ZodString;
+        file: z.ZodString;
+    };
+    readonly knowledge_read: {
+        workspace: z.ZodString;
+        path: z.ZodString;
+    };
+    readonly knowledge_list: {
+        workspace: z.ZodString;
+        directory: z.ZodOptional<z.ZodString>;
+    };
+};
+//# sourceMappingURL=tool-schemas.d.ts.map

package/dist/infrastructure/mcp/tool-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-schemas.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/mcp/tool-schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA8CxB,eAAO,MAAM,6BAA6B,IAA2C,CAAC;AACtF,eAAO,MAAM,8BAA8B;;CAA4C,CAAC;AACxF,eAAO,MAAM,yBAAyB;;;;CAAuC,CAAC;AAC9E,eAAO,MAAM,8BAA8B;;;CAA4C,CAAC;AACxF,eAAO,MAAM,wBAAwB;;;;CAAsC,CAAC;AAC5E,eAAO,MAAM,qBAAqB;;;;CAAmC,CAAC;AACtE,eAAO,MAAM,wBAAwB;;CAAsC,CAAC;AAC5E,eAAO,MAAM,oBAAoB;;;;CAAkC,CAAC;AACpE,eAAO,MAAM,sBAAsB;;;CAAoC,CAAC;AACxE,eAAO,MAAM,mBAAmB;;;CAAiC,CAAC;AAClE,eAAO,MAAM,mBAAmB;;;CAAiC,CAAC;AAElE,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYd,CAAC"}

package/dist/infrastructure/mcp/tool-schemas.js

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+const KnowledgeListWorkspacesInputSchema = z.object({});
+const KnowledgeWorkspaceStatusInputSchema = z.object({
+    workspace: z.string(),
+});
+const KnowledgeIngestTextInputSchema = z.object({
+    workspace: z.string(),
+    content: z.string(),
+    title: z.string().optional(),
+});
+const KnowledgeIngestClipboardInputSchema = z.object({
+    workspace: z.string(),
+    title: z.string().optional(),
+});
+const KnowledgeIngestUrlInputSchema = z.object({
+    workspace: z.string(),
+    url: z.string(),
+    title: z.string().optional(),
+});
+const KnowledgeSearchInputSchema = z.object({
+    workspace: z.string(),
+    query: z.string(),
+    limit: z.number().int().positive().optional(),
+});
+const KnowledgeListInboxInputSchema = z.object({
+    workspace: z.string(),
+});
+const KnowledgeWriteInputSchema = z.object({
+    workspace: z.string(),
+    path: z.string(),
+    content: z.string(),
+});
+const KnowledgeArchiveInputSchema = z.object({
+    workspace: z.string(),
+    file: z.string(),
+});
+const KnowledgeReadInputSchema = z.object({
+    workspace: z.string(),
+    path: z.string(),
+});
+const KnowledgeListInputSchema = z.object({
+    workspace: z.string(),
+    directory: z.string().optional(),
+});
+export const KnowledgeListWorkspacesSchema = KnowledgeListWorkspacesInputSchema.shape;
+export const KnowledgeWorkspaceStatusSchema = KnowledgeWorkspaceStatusInputSchema.shape;
+export const KnowledgeIngestTextSchema = KnowledgeIngestTextInputSchema.shape;
+export const KnowledgeIngestClipboardSchema = KnowledgeIngestClipboardInputSchema.shape;
+export const KnowledgeIngestUrlSchema = KnowledgeIngestUrlInputSchema.shape;
+export const KnowledgeSearchSchema = KnowledgeSearchInputSchema.shape;
+export const KnowledgeListInboxSchema = KnowledgeListInboxInputSchema.shape;
+export const KnowledgeWriteSchema = KnowledgeWriteInputSchema.shape;
+export const KnowledgeArchiveSchema = KnowledgeArchiveInputSchema.shape;
+export const KnowledgeReadSchema = KnowledgeReadInputSchema.shape;
+export const KnowledgeListSchema = KnowledgeListInputSchema.shape;
+export const ToolSchemas = {
+    knowledge_list_workspaces: KnowledgeListWorkspacesSchema,
+    knowledge_workspace_status: KnowledgeWorkspaceStatusSchema,
+    knowledge_ingest_text: KnowledgeIngestTextSchema,
+    knowledge_ingest_clipboard: KnowledgeIngestClipboardSchema,
+    knowledge_ingest_url: KnowledgeIngestUrlSchema,
+    knowledge_search: KnowledgeSearchSchema,
+    knowledge_list_inbox: KnowledgeListInboxSchema,
+    knowledge_write: KnowledgeWriteSchema,
+    knowledge_archive: KnowledgeArchiveSchema,
+    knowledge_read: KnowledgeReadSchema,
+    knowledge_list: KnowledgeListSchema,
+};

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+export {};
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":""}

package/dist/server.js

@@ -0,0 +1,6 @@
+import { startMcpServer } from './infrastructure/mcp/index.js';
+startMcpServer().catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`Fatal: ${message}\n`);
+    process.exit(1);
+});

package/dist/shared/config/config.d.ts

@@ -0,0 +1,4 @@
+import type { ConfigFile } from '../../domains/workspace/workspace.types.js';
+export declare function defaultConfigPath(): string;
+export declare function loadConfig(configPath?: string): ConfigFile;
+//# sourceMappingURL=config.d.ts.map

package/dist/shared/config/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/shared/config/config.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAmB,MAAM,4CAA4C,CAAC;AA2B9F,wBAAgB,iBAAiB,IAAI,MAAM,CAG1C;AAED,wBAAgB,UAAU,CAAC,UAAU,GAAE,MAA4B,GAAG,UAAU,CAa/E"}

package/dist/shared/config/config.js

@@ -0,0 +1,41 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { isAbsolute, join } from 'node:path';
+import { z } from 'zod';
+import { logger } from '../logging/index.js';
+const WorkspaceConfigSchema = z.object({
+    name: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, 'Workspace name must be kebab-case'),
+    path: z.string().refine((value) => isAbsolute(value), 'Workspace path must be absolute'),
+});
+const ConfigSchema = z
+    .object({
+    workspaces: z.array(WorkspaceConfigSchema).default([]),
+})
+    .superRefine((config, context) => {
+    const seen = new Set();
+    for (const workspace of config.workspaces) {
+        if (seen.has(workspace.name)) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `Duplicate workspace name: ${workspace.name}`,
+                path: ['workspaces'],
+            });
+        }
+        seen.add(workspace.name);
+    }
+});
+export function defaultConfigPath() {
+    return join(homedir(), '.chisel', 'config.json');
+}
+export function loadConfig(configPath = defaultConfigPath()) {
+    if (!existsSync(configPath)) {
+        logger.warn({ configPath }, 'Config file not found; starting with zero workspaces');
+        return { workspaces: [] };
+    }
+    const raw = readFileSync(configPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    const result = ConfigSchema.parse(parsed);
+    return {
+        workspaces: result.workspaces,
+    };
+}

package/dist/shared/config/index.d.ts

@@ -0,0 +1,2 @@
+export * from './config.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/shared/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/shared/config/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/dist/shared/config/index.js

@@ -0,0 +1 @@
+export * from './config.js';

package/dist/shared/logging/index.d.ts

@@ -0,0 +1,2 @@
+export * from './logger.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/shared/logging/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/shared/logging/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/dist/shared/logging/index.js

@@ -0,0 +1 @@
+export * from './logger.js';

package/dist/shared/logging/logger.d.ts

@@ -0,0 +1,3 @@
+import pino from 'pino';
+export declare const logger: pino.Logger<never, boolean>;
+//# sourceMappingURL=logger.d.ts.map

package/dist/shared/logging/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/shared/logging/logger.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAC;AAExB,eAAO,MAAM,MAAM,6BAMlB,CAAC"}

package/dist/shared/logging/logger.js

@@ -0,0 +1,5 @@
+import pino from 'pino';
+export const logger = pino({
+    base: null,
+    level: process.env.LOG_LEVEL ?? 'info',
+}, process.stderr);

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@teknologika/chisel-knowledge-mcp",
+  "version": "0.1.0",
+  "description": "Standalone MCP server and library for building and managing knowledge workspaces.",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./server": "./dist/server.js"
+  },
+  "bin": {
+    "chisel-knowledge-mcp": "dist/server.js"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/teknologika/chisel-knowledge-mcp.git"
+  },
+  "license": "MIT",
+  "author": "Teknologika",
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "tsc --noEmit -p tsconfig.json",
+    "test": "vitest"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.17.5",
+    "pino": "^9.9.0",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.29",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4"
+  }
+}