@kognai/build 0.6.0

package/dist/lib/workspace.js

@@ -0,0 +1,221 @@
+"use strict";
+/**
+ * workspace.ts — TICKET-203 Phase 1
+ *
+ * .kognai/ per-project convention: config + knowledge/ + memory/{user,kognai}/.
+ *
+ * Discovery:
+ *   1. Walk up from startDir looking for <dir>/.kognai/config.yaml
+ *   2. Fall back to ~/.kognai/config.yaml
+ *   3. Return null if neither exists
+ *
+ * Config format: minimal YAML subset (scalars, flat lists, flat nested objects).
+ * No external deps — Node 18+ built-ins only.
+ *
+ * Consumed by:
+ *   - knowledge.ts (workspace.knowledge_refs → which docs to read before decompose)
+ *   - memory.ts (workspace.memory_user_dir / memory_kognai_dir → context + summary writes)
+ *   - mandate.ts (workspace field on signed mandate → autonomy envelope)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONFIG = void 0;
+exports.discoverWorkspace = discoverWorkspace;
+exports.readWorkspace = readWorkspace;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+exports.DEFAULT_CONFIG = {
+    version: 1,
+    deliverable_root: './src',
+    knowledge_refs: ['./knowledge'],
+    memory: {
+        user_dir: './memory/user',
+        kognai_dir: './memory/kognai',
+        append_session_summary: true,
+    },
+    defaults: {
+        profile: 'maintainability',
+        task_target: 'cloud-code',
+    },
+};
+function discoverWorkspace(startDir = process.cwd()) {
+    // 1. Walk up from startDir looking for .kognai/config.yaml
+    let dir = (0, path_1.resolve)(startDir);
+    while (true) {
+        const candidate = (0, path_1.join)(dir, '.kognai');
+        if (hasConfig(candidate)) {
+            return readWorkspace(candidate);
+        }
+        const parent = (0, path_1.dirname)(dir);
+        if (parent === dir)
+            break; // hit filesystem root
+        dir = parent;
+    }
+    // 2. Home-level fallback: ~/.kognai/config.yaml
+    const homeKognai = (0, path_1.join)((0, os_1.homedir)(), '.kognai');
+    if (hasConfig(homeKognai)) {
+        return readWorkspace(homeKognai);
+    }
+    return null;
+}
+function readWorkspace(kognaiDir) {
+    const configPath = pickConfigPath(kognaiDir);
+    if (!configPath) {
+        throw new Error(`No config file found at ${kognaiDir} (expected config.yaml, config.yml, or config.json)`);
+    }
+    const raw = (0, fs_1.readFileSync)(configPath, 'utf-8');
+    const config = configPath.endsWith('.json')
+        ? JSON.parse(raw)
+        : parseMinimalYaml(raw);
+    validateConfig(config, configPath);
+    const root = (0, path_1.dirname)(kognaiDir);
+    const resolveRel = (p, base) => (0, path_1.isAbsolute)(p) ? p : (0, path_1.resolve)(base, p);
+    return {
+        root,
+        kognai_dir: kognaiDir,
+        config,
+        deliverable_root: resolveRel(config.deliverable_root, root),
+        // knowledge/ lives INSIDE .kognai/ per TICKET-203 layout (alongside memory/),
+        // so knowledge_refs resolve against kognaiDir — NOT root. The default
+        // './knowledge' must reach .kognai/knowledge, and '../shared-docs/x.md'
+        // still resolves correctly relative to .kognai/. (Bug fix: was `root`,
+        // which silently looked in <project>/knowledge and never loaded anything.)
+        knowledge_refs: config.knowledge_refs.map(p => resolveRel(p, kognaiDir)),
+        memory_user_dir: resolveRel(config.memory.user_dir, kognaiDir),
+        memory_kognai_dir: resolveRel(config.memory.kognai_dir, kognaiDir),
+    };
+}
+// ─── Internals ──────────────────────────────────────────────────────────────
+function hasConfig(kognaiDir) {
+    return pickConfigPath(kognaiDir) !== null;
+}
+function pickConfigPath(kognaiDir) {
+    for (const name of ['config.yaml', 'config.yml', 'config.json']) {
+        const p = (0, path_1.join)(kognaiDir, name);
+        if ((0, fs_1.existsSync)(p) && (0, fs_1.statSync)(p).isFile())
+            return p;
+    }
+    return null;
+}
+function validateConfig(c, path) {
+    if (typeof c.version !== 'number')
+        throw new Error(`${path}: 'version' must be a number`);
+    if (typeof c.deliverable_root !== 'string')
+        throw new Error(`${path}: 'deliverable_root' must be a string`);
+    if (!Array.isArray(c.knowledge_refs))
+        throw new Error(`${path}: 'knowledge_refs' must be an array`);
+    if (!c.memory || typeof c.memory.user_dir !== 'string' || typeof c.memory.kognai_dir !== 'string') {
+        throw new Error(`${path}: 'memory.user_dir' and 'memory.kognai_dir' are required`);
+    }
+    if (typeof c.memory.append_session_summary !== 'boolean') {
+        throw new Error(`${path}: 'memory.append_session_summary' must be a boolean`);
+    }
+    if (!c.defaults || typeof c.defaults !== 'object')
+        throw new Error(`${path}: 'defaults' must be an object`);
+}
+/**
+ * Minimal YAML parser for the .kognai/config.yaml subset.
+ *
+ * Supports:
+ *   - Scalars: strings (quoted or bare), numbers, booleans (true/false), null
+ *   - Comments (# to end of line; preserves # inside quoted strings)
+ *   - Top-level keys with scalar / array / object values
+ *   - One level of nesting (memory: { user_dir, kognai_dir, append_session_summary })
+ *   - Block-style arrays of scalars (- item)
+ *
+ * Does NOT support: anchors/aliases, multiline strings, flow style, arrays of objects.
+ * That's enough for the config schema. Add deps later if richer needs emerge.
+ */
+function parseMinimalYaml(text) {
+    const result = {};
+    const lines = text.split(/\r?\n/);
+    let currentKey = null; // top-level key whose value is an array or object
+    let currentMode = null;
+    let currentIndent = -1;
+    for (let i = 0; i < lines.length; i++) {
+        const raw = lines[i];
+        const line = stripComment(raw);
+        if (!line.trim())
+            continue;
+        const indent = line.match(/^(\s*)/)[1].length;
+        const trimmed = line.trim();
+        // Top-level scalar/list/object opener at indent 0
+        if (indent === 0) {
+            const m = trimmed.match(/^([A-Za-z_][\w-]*)\s*:\s*(.*)$/);
+            if (!m)
+                throw new Error(`Malformed YAML at line ${i + 1}: ${raw}`);
+            const [, key, rest] = m;
+            if (rest === '') {
+                // Could be array (next non-empty line starts with '-') or object (indented k:v)
+                currentKey = key;
+                currentMode = null; // decide on first child line
+                currentIndent = -1;
+                result[key] = null; // placeholder
+            }
+            else {
+                result[key] = parseScalar(rest);
+                currentKey = null;
+                currentMode = null;
+            }
+            continue;
+        }
+        // Inside an open block — first child decides array vs object
+        if (currentKey === null) {
+            throw new Error(`Unexpected indented line ${i + 1}: ${raw}`);
+        }
+        if (currentMode === null) {
+            currentMode = trimmed.startsWith('- ') ? 'array' : 'object';
+            currentIndent = indent;
+            result[currentKey] = currentMode === 'array' ? [] : {};
+        }
+        if (indent !== currentIndent) {
+            throw new Error(`Inconsistent indentation at line ${i + 1}: expected ${currentIndent}, got ${indent}`);
+        }
+        if (currentMode === 'array') {
+            const m = trimmed.match(/^-\s*(.*)$/);
+            if (!m)
+                throw new Error(`Expected list item at line ${i + 1}: ${raw}`);
+            result[currentKey].push(parseScalar(m[1]));
+        }
+        else {
+            const m = trimmed.match(/^([A-Za-z_][\w-]*)\s*:\s*(.*)$/);
+            if (!m)
+                throw new Error(`Expected key:value at line ${i + 1}: ${raw}`);
+            const [, k, v] = m;
+            result[currentKey][k] = parseScalar(v);
+        }
+    }
+    return result;
+}
+function stripComment(line) {
+    // Preserve # inside double or single quotes
+    let inDouble = false, inSingle = false;
+    for (let i = 0; i < line.length; i++) {
+        const c = line[i];
+        if (c === '"' && !inSingle)
+            inDouble = !inDouble;
+        else if (c === "'" && !inDouble)
+            inSingle = !inSingle;
+        else if (c === '#' && !inDouble && !inSingle)
+            return line.slice(0, i).trimEnd();
+    }
+    return line;
+}
+function parseScalar(s) {
+    const t = s.trim();
+    if (t === '' || t === '~' || t === 'null')
+        return null;
+    if (t === 'true')
+        return true;
+    if (t === 'false')
+        return false;
+    if (/^-?\d+$/.test(t))
+        return parseInt(t, 10);
+    if (/^-?\d+\.\d+$/.test(t))
+        return parseFloat(t);
+    // Strip matched quotes
+    if ((t.startsWith('"') && t.endsWith('"')) || (t.startsWith("'") && t.endsWith("'"))) {
+        return t.slice(1, -1);
+    }
+    return t;
+}

package/dist/templates/index.js

@@ -0,0 +1,184 @@
+"use strict";
+/**
+ * Template Registry
+ *
+ * Hardcoded starter templates for the Kognai build system.
+ * Each template encodes intent matching keywords, default quality profile,
+ * agent composition, workflow shape, and required skills/tools.
+ *
+ * Source: TICKET-140 (template registry seed data)
+ * Profile axes per TICKET-135: security, reliability, performance,
+ * maintainability, compatibility, usability, portability, compliance,
+ * cost-efficiency, time-to-market, sovereignty, quality (composite).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STARTER_TEMPLATES = void 0;
+exports.STARTER_TEMPLATES = [
+    {
+        id: 'research-synthesis-default',
+        name: 'Research Synthesis (Default)',
+        intent: ['literature review', 'research', 'synthesis', 'paper', 'citation'],
+        default_profile: {
+            primary: 'quality',
+            secondary: ['maintainability'],
+        },
+        composition: {
+            roles: [
+                { role: 'researcher', count: 2 },
+                { role: 'synthesizer', count: 1 },
+                { role: 'reviewer', count: 1 },
+            ],
+        },
+        workflow: 'gather sources → extract claims → cross-reference citations → synthesize narrative → peer-review for accuracy → ship if approved',
+        skills: ['citation-validation', 'source-credibility', 'claim-extraction'],
+        tools: ['web-search', 'pdf-reader', 'citation-manager'],
+    },
+    {
+        id: 'content-creation-default',
+        name: 'Content Creation (Default)',
+        intent: ['blog', 'post', 'article', 'content', 'copy'],
+        default_profile: {
+            primary: 'time-to-market',
+            secondary: ['quality'],
+        },
+        composition: {
+            roles: [
+                { role: 'writer', count: 1 },
+                { role: 'editor', count: 1 },
+            ],
+        },
+        workflow: 'outline → draft → self-edit → editorial review → polish → ship',
+        skills: ['copywriting', 'tone-matching', 'seo-basics'],
+        tools: ['markdown-editor', 'grammar-checker', 'readability-scorer'],
+    },
+    {
+        id: 'webapp-standard-default',
+        name: 'Web App Standard (Default)',
+        intent: ['web app', 'dashboard', 'crud', 'frontend', 'react'],
+        default_profile: {
+            primary: 'time-to-market',
+            secondary: ['maintainability'],
+        },
+        composition: {
+            roles: [
+                { role: 'coder', count: 2 },
+                { role: 'reviewer', count: 1 },
+            ],
+        },
+        workflow: 'decompose → atomic single-file tasks → implement components → review → integrate → ship',
+        skills: ['react-patterns', 'state-management', 'api-integration'],
+        tools: ['vite', 'typescript-checker', 'eslint'],
+    },
+    {
+        id: 'defi-security-first',
+        name: 'DeFi Security First',
+        intent: ['defi', 'smart contract', 'solidity', 'on-chain', 'financial primitive'],
+        default_profile: {
+            primary: 'security',
+            secondary: ['reliability', 'compliance'],
+        },
+        composition: {
+            roles: [
+                { role: 'coder', count: 1 },
+                { role: 'security-reviewer', count: 2 },
+                { role: 'auditor', count: 1 },
+            ],
+        },
+        workflow: 'threat-model → implement with invariants → dual-review with adversarial lens → static analysis → fuzz testing → ship only if all reviewers approve',
+        skills: ['invariant-analysis', 'reentrancy-detection', 'gas-optimization'],
+        tools: ['slither', 'foundry', 'echidna-fuzzer'],
+    },
+    {
+        id: 'healthcare-compliance-first',
+        name: 'Healthcare Compliance First',
+        intent: ['healthcare', 'medical', 'hipaa', 'patient', 'regulated'],
+        default_profile: {
+            primary: 'compliance',
+            secondary: ['security', 'maintainability'],
+        },
+        composition: {
+            roles: [
+                { role: 'coder', count: 1 },
+                { role: 'compliance-reviewer', count: 1 },
+                { role: 'security-reviewer', count: 1 },
+            ],
+        },
+        workflow: 'decompose → atomic single-file tasks → dual-review with compliance lens → audit-log every PHI touchpoint → ship if approved',
+        skills: ['schema-validation', 'audit-logging', 'phi-redaction'],
+        tools: ['postgres-encrypted', 'hipaa-bcc-checker', 'audit-trail-emitter'],
+    },
+    {
+        id: 'internal-tooling-default',
+        name: 'Internal Tooling (Default)',
+        intent: ['internal', 'tooling', 'script', 'cli', 'devtool'],
+        default_profile: {
+            primary: 'cost-efficiency',
+            secondary: ['maintainability'],
+        },
+        composition: {
+            roles: [
+                { role: 'coder', count: 1 },
+                { role: 'reviewer', count: 1 },
+            ],
+        },
+        workflow: 'lightweight spec → implement → smoke test → ship to internal users',
+        skills: ['cli-design', 'argument-parsing', 'shell-scripting'],
+        tools: ['commander', 'bash', 'node-runtime'],
+    },
+    {
+        id: 'data-pipeline-reliability',
+        name: 'Data Pipeline Reliability',
+        intent: ['data pipeline', 'etl', 'ingestion', 'transform'],
+        default_profile: {
+            primary: 'reliability',
+            secondary: ['performance', 'maintainability'],
+        },
+        composition: {
+            roles: [
+                { role: 'coder', count: 1 },
+                { role: 'data-reviewer', count: 1 },
+                { role: 'sre', count: 1 },
+            ],
+        },
+        workflow: 'schema-first design → implement with retries + idempotency → backfill test → review for failure modes → ship with monitoring',
+        skills: ['schema-validation', 'idempotency-design', 'backpressure-handling'],
+        tools: ['airflow', 'dbt', 'great-expectations'],
+    },
+    {
+        id: 'realtime-performance-first',
+        name: 'Realtime Performance First',
+        intent: ['realtime', 'latency', 'websocket', 'streaming', 'low-latency'],
+        default_profile: {
+            primary: 'performance',
+            secondary: ['reliability'],
+        },
+        composition: {
+            roles: [
+                { role: 'coder', count: 1 },
+                { role: 'performance-reviewer', count: 1 },
+            ],
+        },
+        workflow: 'benchmark baseline → implement hot path → profile → optimize → load-test → ship if p99 budget met',
+        skills: ['profiling', 'concurrency-patterns', 'memory-management'],
+        tools: ['k6', 'clinic-js', 'websocket-bench'],
+    },
+    {
+        id: 'video-production-default',
+        name: 'Video Production (Default)',
+        intent: ['video', 'pipeline', 'scorsese', 'render', 'hyperframes'],
+        default_profile: {
+            primary: 'quality',
+            secondary: ['time-to-market'],
+        },
+        composition: {
+            roles: [
+                { role: 'director', count: 1 },
+                { role: 'coder', count: 1 },
+                { role: 'reviewer', count: 1 },
+            ],
+        },
+        workflow: 'storyboard → scene composition → render preview → review → final render → ship',
+        skills: ['composition-design', 'timing-coordination', 'audio-sync'],
+        tools: ['hyperframes', 'ffmpeg', 'scorsese-renderer'],
+    },
+];

package/dist/templates/registry.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectTemplates = selectTemplates;
+exports.getTemplateById = getTemplateById;
+const index_1 = require("./index");
+function countIntentMatches(intentKeywords, userGoal) {
+    const normalizedGoal = userGoal.toLowerCase();
+    const matched = [];
+    for (const keyword of intentKeywords) {
+        if (typeof keyword !== 'string' || keyword.length === 0) {
+            continue;
+        }
+        if (normalizedGoal.includes(keyword.toLowerCase())) {
+            matched.push(keyword);
+        }
+    }
+    return { matched, count: matched.length };
+}
+function selectTemplates(userGoal, profileOverride, topN = 3) {
+    if (typeof userGoal !== 'string') {
+        return [];
+    }
+    const limit = Number.isFinite(topN) && topN > 0 ? Math.floor(topN) : 3;
+    const candidates = [];
+    for (const template of index_1.STARTER_TEMPLATES) {
+        if (profileOverride !== undefined &&
+            profileOverride !== null &&
+            template.default_profile.primary !== profileOverride) {
+            continue;
+        }
+        const intentKeywords = template.intent ?? [];
+        const totalKeywords = intentKeywords.length;
+        if (totalKeywords === 0) {
+            candidates.push({
+                template,
+                score: 0,
+                matchedKeywords: [],
+                intentLength: 0,
+            });
+            continue;
+        }
+        const { matched, count } = countIntentMatches(intentKeywords, userGoal);
+        const score = count / totalKeywords;
+        candidates.push({
+            template,
+            score,
+            matchedKeywords: matched,
+            intentLength: totalKeywords,
+        });
+    }
+    candidates.sort((a, b) => {
+        if (b.score !== a.score) {
+            return b.score - a.score;
+        }
+        if (a.intentLength !== b.intentLength) {
+            return a.intentLength - b.intentLength;
+        }
+        return a.template.id.localeCompare(b.template.id);
+    });
+    const top = candidates.slice(0, limit);
+    return top.map((candidate) => {
+        const profileLabel = profileOverride !== undefined && profileOverride !== null
+            ? profileOverride
+            : candidate.template.default_profile.primary;
+        const keywordList = candidate.matchedKeywords.length > 0
+            ? candidate.matchedKeywords.join(', ')
+            : 'none';
+        const reason = `matched keywords: [${keywordList}]; profile: [${profileLabel}]`;
+        return {
+            template: candidate.template,
+            score: candidate.score,
+            reason,
+        };
+    });
+}
+function getTemplateById(id) {
+    if (typeof id !== 'string' || id.length === 0) {
+        return null;
+    }
+    const found = index_1.STARTER_TEMPLATES.find((template) => template.id === id);
+    return found ?? null;
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@kognai/build",
+  "version": "0.6.0",
+  "description": "Kognai sovereign orchestrator — interactive REPL (kognai) + one-shot CLI (kognai-build). Triple-supervisor + compliance review + TICKET-135 optimization profiles + TICKET-203/207 workspace integration.",
+  "license": "MIT",
+  "author": "SkinGem",
+  "bin": {
+    "kognai": "./dist/bin/kognai.js",
+    "kognai-build": "./dist/bin/kognai-build.js"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && rm -f dist/tsconfig.tsbuildinfo && chmod +x dist/bin/kognai.js dist/bin/kognai-build.js",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "kognai",
+    "agent",
+    "orchestrator",
+    "ai",
+    "claude",
+    "compliance",
+    "code-generation",
+    "sovereign"
+  ],
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.65.0",
+    "@kognai/orchestrator-core": "^0.1.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SkinGem/kognai.git",
+    "directory": "packages/kognai-build"
+  }
+}