iranti 0.1.0

package/dist/scripts/api-key-list.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv/config");
+const client_1 = require("../src/library/client");
+const apiKeys_1 = require("../src/security/apiKeys");
+async function main() {
+    const dbUrl = process.env.DATABASE_URL;
+    if (!dbUrl) {
+        console.error('DATABASE_URL is required.');
+        process.exit(1);
+    }
+    (0, client_1.initDb)(dbUrl);
+    const keys = await (0, apiKeys_1.listApiKeys)();
+    if (keys.length === 0) {
+        console.log('No registry API keys found.');
+    }
+    else {
+        console.log(`Found ${keys.length} registry API key(s):\n`);
+        for (const key of keys) {
+            console.log(`- keyId: ${key.keyId}`);
+            console.log(`  owner: ${key.owner}`);
+            console.log(`  active: ${key.isActive}`);
+            console.log(`  scopes: ${key.scopes.join(',') || '(none)'}`);
+            console.log(`  createdAt: ${key.createdAt}`);
+            if (key.revokedAt) {
+                console.log(`  revokedAt: ${key.revokedAt}`);
+            }
+        }
+    }
+    await (0, client_1.getDb)().$disconnect();
+}
+main().catch(async (err) => {
+    console.error('Failed to list API keys:', err instanceof Error ? err.message : String(err));
+    try {
+        await (0, client_1.getDb)().$disconnect();
+    }
+    catch {
+        // ignore
+    }
+    process.exit(1);
+});
+//# sourceMappingURL=api-key-list.js.map

package/dist/scripts/api-key-revoke.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv/config");
+const client_1 = require("../src/library/client");
+const apiKeys_1 = require("../src/security/apiKeys");
+function parseArg(flag) {
+    const idx = process.argv.indexOf(flag);
+    if (idx === -1)
+        return undefined;
+    return process.argv[idx + 1];
+}
+async function main() {
+    const keyId = parseArg('--key-id') ?? parseArg('-k');
+    if (!keyId) {
+        console.error('Usage: npm run api-key:revoke -- --key-id <id>');
+        process.exit(1);
+    }
+    const dbUrl = process.env.DATABASE_URL;
+    if (!dbUrl) {
+        console.error('DATABASE_URL is required.');
+        process.exit(1);
+    }
+    (0, client_1.initDb)(dbUrl);
+    const revoked = await (0, apiKeys_1.revokeApiKey)(keyId);
+    if (!revoked) {
+        console.error(`API key not found: ${keyId}`);
+        process.exit(1);
+    }
+    console.log(`Revoked API key: ${keyId}`);
+    await (0, client_1.getDb)().$disconnect();
+}
+main().catch(async (err) => {
+    console.error('Failed to revoke API key:', err instanceof Error ? err.message : String(err));
+    try {
+        await (0, client_1.getDb)().$disconnect();
+    }
+    catch {
+        // ignore
+    }
+    process.exit(1);
+});
+//# sourceMappingURL=api-key-revoke.js.map

package/dist/scripts/iranti-cli.js

@@ -0,0 +1,387 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+function parseArgs(argv) {
+    const flags = new Map();
+    const positionals = [];
+    for (let i = 0; i < argv.length; i++) {
+        const token = argv[i];
+        if (token.startsWith('--')) {
+            const key = token.slice(2);
+            const next = argv[i + 1];
+            if (!next || next.startsWith('--')) {
+                flags.set(key, true);
+            }
+            else {
+                flags.set(key, next);
+                i++;
+            }
+            continue;
+        }
+        positionals.push(token);
+    }
+    return {
+        command: positionals[0] ?? null,
+        subcommand: positionals[1] ?? null,
+        positionals: positionals.slice(2),
+        flags,
+    };
+}
+function getFlag(args, key) {
+    const value = args.flags.get(key);
+    return typeof value === 'string' ? value : undefined;
+}
+function hasFlag(args, key) {
+    return Boolean(args.flags.get(key));
+}
+function normalizeScope(raw) {
+    if (!raw)
+        return 'user';
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === 'user' || normalized === 'system')
+        return normalized;
+    throw new Error(`Invalid scope '${raw}'. Use --scope user or --scope system.`);
+}
+function defaultInstallRoot(scope) {
+    const platform = process.platform;
+    if (platform === 'win32') {
+        if (scope === 'system') {
+            const programData = process.env.ProgramData ?? 'C:\\ProgramData';
+            return path_1.default.join(programData, 'Iranti');
+        }
+        return path_1.default.join(os_1.default.homedir(), '.iranti');
+    }
+    if (platform === 'darwin') {
+        if (scope === 'system')
+            return '/Library/Application Support/Iranti';
+        return path_1.default.join(os_1.default.homedir(), 'Library', 'Application Support', 'iranti');
+    }
+    // linux and other unix-like
+    if (scope === 'system')
+        return '/var/lib/iranti';
+    return path_1.default.join(os_1.default.homedir(), '.local', 'share', 'iranti');
+}
+function resolveInstallRoot(args, scope) {
+    const explicit = getFlag(args, 'root') ?? process.env.IRANTI_HOME;
+    if (explicit)
+        return path_1.default.resolve(explicit);
+    const userRoot = defaultInstallRoot('user');
+    const systemRoot = defaultInstallRoot('system');
+    const userMeta = path_1.default.join(userRoot, 'install.json');
+    const systemMeta = path_1.default.join(systemRoot, 'install.json');
+    if (scope === 'system')
+        return systemRoot;
+    if (fs_1.default.existsSync(userMeta))
+        return userRoot;
+    if (fs_1.default.existsSync(systemMeta))
+        return systemRoot;
+    return userRoot;
+}
+function getPackageVersion() {
+    let dir = __dirname;
+    for (let i = 0; i < 5; i++) {
+        const pkgPath = path_1.default.join(dir, 'package.json');
+        if (fs_1.default.existsSync(pkgPath)) {
+            try {
+                const raw = fs_1.default.readFileSync(pkgPath, 'utf-8');
+                const pkg = JSON.parse(raw);
+                return String(pkg.version ?? '0.0.0');
+            }
+            catch {
+                return '0.0.0';
+            }
+        }
+        const parent = path_1.default.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return '0.0.0';
+}
+async function ensureDir(dir) {
+    await promises_1.default.mkdir(dir, { recursive: true });
+}
+async function writeJson(filePath, value) {
+    await promises_1.default.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
+}
+async function writeText(filePath, content) {
+    await promises_1.default.writeFile(filePath, content, 'utf-8');
+}
+async function readEnvFile(filePath) {
+    const out = {};
+    const raw = await promises_1.default.readFile(filePath, 'utf-8');
+    for (const line of raw.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const idx = trimmed.indexOf('=');
+        if (idx <= 0)
+            continue;
+        const key = trimmed.slice(0, idx).trim();
+        const valueRaw = trimmed.slice(idx + 1).trim();
+        const value = (valueRaw.startsWith('"') && valueRaw.endsWith('"')) ||
+            (valueRaw.startsWith("'") && valueRaw.endsWith("'"))
+            ? valueRaw.slice(1, -1)
+            : valueRaw;
+        out[key] = value;
+    }
+    return out;
+}
+function makeInstanceEnv(name, port, dbUrl, apiKey, instanceDir) {
+    const lines = [
+        '# Iranti instance env',
+        `IRANTI_INSTANCE_NAME=${name}`,
+        `IRANTI_PORT=${port}`,
+        `DATABASE_URL=${dbUrl}`,
+        'LLM_PROVIDER=mock',
+        `IRANTI_ESCALATION_DIR=${path_1.default.join(instanceDir, 'escalation')}`,
+        `IRANTI_REQUEST_LOG_FILE=${path_1.default.join(instanceDir, 'logs', 'api-requests.log')}`,
+        'IRANTI_ARCHIVIST_WATCH=true',
+        'IRANTI_ARCHIVIST_DEBOUNCE_MS=60000',
+        'IRANTI_ARCHIVIST_INTERVAL_MS=0',
+        `IRANTI_API_KEY=${apiKey ?? 'replace_me_with_api_key'}`,
+        '',
+    ];
+    return lines.join('\n');
+}
+async function installCommand(args) {
+    const scope = normalizeScope(getFlag(args, 'scope'));
+    const root = resolveInstallRoot(args, scope);
+    await ensureDir(root);
+    await ensureDir(path_1.default.join(root, 'instances'));
+    await ensureDir(path_1.default.join(root, 'logs'));
+    await ensureDir(path_1.default.join(root, 'tmp'));
+    const meta = {
+        version: getPackageVersion(),
+        scope,
+        root,
+        installedAt: new Date().toISOString(),
+    };
+    await writeJson(path_1.default.join(root, 'install.json'), meta);
+    console.log(`Iranti runtime initialized`);
+    console.log(`  scope: ${scope}`);
+    console.log(`  root : ${root}`);
+    console.log(`Next: iranti instance create local --port 3001`);
+}
+async function createInstanceCommand(args) {
+    const name = args.positionals[0];
+    if (!name) {
+        throw new Error('Missing instance name. Usage: iranti instance create <name> [--port 3001]');
+    }
+    const scope = normalizeScope(getFlag(args, 'scope'));
+    const root = resolveInstallRoot(args, scope);
+    const portRaw = getFlag(args, 'port') ?? '3001';
+    const port = Number.parseInt(portRaw, 10);
+    if (!Number.isFinite(port) || port <= 0)
+        throw new Error(`Invalid --port '${portRaw}'.`);
+    const dbUrl = getFlag(args, 'db-url') ??
+        `postgresql://postgres:yourpassword@localhost:5432/iranti_${name}`;
+    const apiKey = getFlag(args, 'api-key');
+    const instanceDir = path_1.default.join(root, 'instances', name);
+    const envFile = path_1.default.join(instanceDir, '.env');
+    if (fs_1.default.existsSync(instanceDir) && !hasFlag(args, 'force')) {
+        throw new Error(`Instance '${name}' already exists at ${instanceDir}. Use --force to overwrite.`);
+    }
+    await ensureDir(instanceDir);
+    await ensureDir(path_1.default.join(instanceDir, 'logs'));
+    await ensureDir(path_1.default.join(instanceDir, 'escalation', 'active'));
+    await ensureDir(path_1.default.join(instanceDir, 'escalation', 'resolved'));
+    await ensureDir(path_1.default.join(instanceDir, 'escalation', 'archived'));
+    await writeText(envFile, makeInstanceEnv(name, port, dbUrl, apiKey, instanceDir));
+    const meta = {
+        name,
+        createdAt: new Date().toISOString(),
+        port,
+        envFile,
+        instanceDir,
+    };
+    await writeJson(path_1.default.join(instanceDir, 'instance.json'), meta);
+    console.log(`Instance created: ${name}`);
+    console.log(`  dir : ${instanceDir}`);
+    console.log(`  env : ${envFile}`);
+    console.log(`  port: ${port}`);
+    console.log(`Next: iranti instance show ${name}`);
+}
+async function listInstancesCommand(args) {
+    const scope = normalizeScope(getFlag(args, 'scope'));
+    const root = resolveInstallRoot(args, scope);
+    const instancesDir = path_1.default.join(root, 'instances');
+    if (!fs_1.default.existsSync(instancesDir)) {
+        console.log(`No install found at ${root}. Run: iranti install`);
+        return;
+    }
+    const entries = await promises_1.default.readdir(instancesDir, { withFileTypes: true });
+    const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
+    if (dirs.length === 0) {
+        console.log(`No instances found under ${instancesDir}`);
+        return;
+    }
+    console.log(`Instances (${instancesDir}):`);
+    for (const name of dirs) {
+        const metaPath = path_1.default.join(instancesDir, name, 'instance.json');
+        if (fs_1.default.existsSync(metaPath)) {
+            try {
+                const raw = await promises_1.default.readFile(metaPath, 'utf-8');
+                const meta = JSON.parse(raw);
+                console.log(`  - ${name} (port ${meta.port})`);
+                continue;
+            }
+            catch {
+                // fall through
+            }
+        }
+        console.log(`  - ${name}`);
+    }
+}
+async function showInstanceCommand(args) {
+    const name = args.positionals[0];
+    if (!name)
+        throw new Error('Missing instance name. Usage: iranti instance show <name>');
+    const scope = normalizeScope(getFlag(args, 'scope'));
+    const root = resolveInstallRoot(args, scope);
+    const instanceDir = path_1.default.join(root, 'instances', name);
+    const envFile = path_1.default.join(instanceDir, '.env');
+    if (!fs_1.default.existsSync(envFile))
+        throw new Error(`Instance '${name}' not found at ${instanceDir}`);
+    const env = await readEnvFile(envFile);
+    console.log(`Instance: ${name}`);
+    console.log(`  dir : ${instanceDir}`);
+    console.log(`  env : ${envFile}`);
+    console.log(`  port: ${env.IRANTI_PORT ?? '3001'}`);
+    console.log(`  db  : ${env.DATABASE_URL ?? '(missing)'}`);
+    console.log(`  esc : ${env.IRANTI_ESCALATION_DIR ?? '(missing)'}`);
+    console.log(`Run with: iranti run --instance ${name}`);
+}
+async function runInstanceCommand(args) {
+    const name = getFlag(args, 'instance') ?? args.positionals[0] ?? args.subcommand;
+    if (!name)
+        throw new Error('Missing instance name. Usage: iranti run --instance <name>');
+    const scope = normalizeScope(getFlag(args, 'scope'));
+    const root = resolveInstallRoot(args, scope);
+    const envFile = path_1.default.join(root, 'instances', name, '.env');
+    if (!fs_1.default.existsSync(envFile))
+        throw new Error(`Instance '${name}' not found. Create it first.`);
+    const env = await readEnvFile(envFile);
+    for (const [k, v] of Object.entries(env)) {
+        process.env[k] = v;
+    }
+    if (!process.env.DATABASE_URL || process.env.DATABASE_URL.includes('yourpassword')) {
+        throw new Error(`Instance '${name}' has placeholder DATABASE_URL. Edit ${envFile} first.`);
+    }
+    console.log(`Starting Iranti instance '${name}' on port ${process.env.IRANTI_PORT ?? '3001'}...`);
+    const serverEntry = path_1.default.resolve(__dirname, '..', 'src', 'api', 'server');
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    require(serverEntry);
+}
+async function projectInitCommand(args) {
+    const projectPath = path_1.default.resolve(args.positionals[0] ?? process.cwd());
+    const instanceName = getFlag(args, 'instance');
+    if (!instanceName) {
+        throw new Error('Missing --instance <name>. Usage: iranti project init [path] --instance <name>');
+    }
+    const scope = normalizeScope(getFlag(args, 'scope'));
+    const root = resolveInstallRoot(args, scope);
+    const envFile = path_1.default.join(root, 'instances', instanceName, '.env');
+    if (!fs_1.default.existsSync(envFile))
+        throw new Error(`Instance '${instanceName}' not found. Create it first.`);
+    const instanceEnv = await readEnvFile(envFile);
+    const port = instanceEnv.IRANTI_PORT ?? '3001';
+    const apiKey = getFlag(args, 'api-key') ?? instanceEnv.IRANTI_API_KEY ?? 'replace_me_with_api_key';
+    const agentId = getFlag(args, 'agent-id') ?? 'my_agent';
+    await ensureDir(projectPath);
+    const outFile = path_1.default.join(projectPath, '.env.iranti');
+    if (fs_1.default.existsSync(outFile) && !hasFlag(args, 'force')) {
+        throw new Error(`${outFile} already exists. Use --force to overwrite.`);
+    }
+    const content = [
+        '# Iranti project binding',
+        `IRANTI_URL=http://localhost:${port}`,
+        `IRANTI_API_KEY=${apiKey}`,
+        `IRANTI_AGENT_ID=${agentId}`,
+        'IRANTI_MEMORY_ENTITY=user/main',
+        `IRANTI_INSTANCE=${instanceName}`,
+        `IRANTI_INSTANCE_ENV=${envFile}`,
+        '',
+    ].join('\n');
+    await writeText(outFile, content);
+    const gitignorePath = path_1.default.join(projectPath, '.gitignore');
+    const requiredLines = ['.env.iranti', '.env.iranti.local'];
+    if (fs_1.default.existsSync(gitignorePath)) {
+        const raw = await promises_1.default.readFile(gitignorePath, 'utf-8');
+        const existing = new Set(raw.split(/\r?\n/));
+        const missing = requiredLines.filter((line) => !existing.has(line));
+        if (missing.length > 0) {
+            await promises_1.default.writeFile(gitignorePath, `${raw.trimEnd()}\n${missing.join('\n')}\n`, 'utf-8');
+        }
+    }
+    else {
+        await writeText(gitignorePath, `${requiredLines.join('\n')}\n`);
+    }
+    console.log(`Project initialized at ${projectPath}`);
+    console.log(`  wrote ${outFile}`);
+    console.log(`Use with Python client/middleware by loading .env.iranti`);
+}
+function printHelp() {
+    console.log(`Iranti CLI
+
+Machine-level:
+  iranti install [--scope user|system] [--root <path>]
+
+Instance-level:
+  iranti instance create <name> [--port 3001] [--db-url <url>] [--api-key <token>] [--scope user|system]
+  iranti instance list [--scope user|system]
+  iranti instance show <name> [--scope user|system]
+  iranti run --instance <name> [--scope user|system]
+
+Project-level:
+  iranti project init [path] --instance <name> [--api-key <token>] [--agent-id <id>] [--force]
+`);
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (!args.command || args.command === 'help' || args.command === '--help') {
+        printHelp();
+        return;
+    }
+    if (args.command === 'install') {
+        await installCommand(args);
+        return;
+    }
+    if (args.command === 'instance') {
+        if (args.subcommand === 'create') {
+            await createInstanceCommand(args);
+            return;
+        }
+        if (args.subcommand === 'list') {
+            await listInstancesCommand(args);
+            return;
+        }
+        if (args.subcommand === 'show') {
+            await showInstanceCommand(args);
+            return;
+        }
+        throw new Error(`Unknown instance subcommand '${args.subcommand ?? ''}'.`);
+    }
+    if (args.command === 'run') {
+        await runInstanceCommand(args);
+        return;
+    }
+    if (args.command === 'project' && args.subcommand === 'init') {
+        await projectInitCommand(args);
+        return;
+    }
+    throw new Error(`Unknown command '${args.command}'. Run: iranti help`);
+}
+main().catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Error: ${message}`);
+    process.exit(1);
+});
+//# sourceMappingURL=iranti-cli.js.map

package/dist/scripts/seed-codebase.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv/config");
+const sdk_1 = require("../src/sdk");
+async function seedCodebase() {
+    console.log('Seeding codebase knowledge...');
+    const iranti = new sdk_1.Iranti();
+    const facts = [
+        {
+            key: 'npm_packages',
+            value: {
+                dependencies: {
+                    '@anthropic-ai/sdk': '^0.78.0',
+                    '@prisma/adapter-pg': '^7.4.2',
+                    '@prisma/client': '^7.4.2',
+                    'dotenv': '^17.3.1',
+                    'pg': '^8.19.0',
+                    'prisma': '^7.4.2',
+                },
+                devDependencies: {
+                    '@types/pg': '^8.16.0',
+                    'ts-node': '^10.9.2',
+                    'typescript': '^5.0.0',
+                },
+                installCommand: 'npm install',
+            },
+            summary: 'NPM packages — prisma@7.4.2, pg@8.19.0, dotenv@17.3.1, typescript@5.0.0, @anthropic-ai/sdk@0.78.0',
+        },
+        {
+            key: 'database',
+            value: {
+                engine: 'PostgreSQL',
+                version: '16',
+                name: 'iranti',
+                user: 'postgres',
+                host: 'localhost',
+                port: 5432,
+                notes: 'No password required in default local setup. Docker container: iranti_db.',
+            },
+            summary: 'PostgreSQL 16, database name iranti, user postgres, port 5432, Docker container iranti_db',
+        },
+        {
+            key: 'tech_stack',
+            value: {
+                language: 'TypeScript',
+                runtime: 'Node.js',
+                orm: 'Prisma v7',
+                prismaNotes: 'Requires @prisma/adapter-pg and PrismaPg adapter. Generator output: src/generated/prisma. Package versions: prisma@7.4.2, @prisma/adapter-pg@7.4.2, @prisma/client@7.4.2.',
+                runner: 'ts-node for scripts, tsc for build',
+                target: 'ES2020, commonjs modules',
+            },
+            summary: 'TypeScript, Node.js, Prisma v7 with PrismaPg adapter, ts-node runner',
+        },
+        {
+            key: 'schema',
+            value: {
+                tables: ['knowledge_base', 'archive', 'entity_relationships'],
+                uniqueConstraints: {
+                    knowledge_base: ['entityType', 'entityId', 'key'],
+                    entity_relationships: ['fromType', 'fromId', 'relationshipType', 'toType', 'toId'],
+                },
+                jsonColumns: ['valueRaw', 'conflictLog', 'properties'],
+                protectedNamespace: 'entityType = system',
+            },
+            summary: '3 tables: knowledge_base, archive, entity_relationships. Unique on entityType/entityId/key.',
+        },
+        {
+            key: 'llm_providers',
+            value: {
+                current: 'mock',
+                available: ['mock', 'gemini', 'claude'],
+                switchBy: 'LLM_PROVIDER env var',
+                geminiModel: 'gemini-2.0-flash-001',
+                conflictResolutionModel: 'gemini-2.5-pro',
+                rateLimit: 'Free Gemini tier: 10 req/min on gemini-2.0-flash-001',
+            },
+            summary: 'LLM provider set via LLM_PROVIDER env var. Current: mock. Gemini and Claude implemented.',
+        },
+        {
+            key: 'architecture_decisions',
+            value: {
+                license: 'AGPL — allows free self-hosting, protects hosted business',
+                attendant: 'Per-agent class, singleton registry, persists state to KB',
+                librarian: 'Shared instance, owns all DB writes',
+                conflictThreshold: 'Gap >= 10 confidence points = deterministic resolution. Gap < 10 = LLM reasoning.',
+                escalationFormat: 'Status must be exactly "**Status:** RESOLVED" for Archivist to process',
+                entityFormat: 'entityType/entityId string in SDK e.g. researcher/jane_smith',
+                propertiesColumn: 'Escape hatch for caller-defined metadata, no migrations needed',
+            },
+            summary: 'AGPL license, per-agent Attendants, shared Librarian, conflict threshold 10 points',
+        },
+        {
+            key: 'open_questions',
+            value: {
+                hostedPricing: 'Consumption-based, reference Upstash model',
+                archiveRetention: 'Indefinite vs rolling window — undecided',
+                sdkLanguages: 'TypeScript first, Python SDK planned',
+            },
+            summary: 'Open: hosted pricing model, archive retention policy, Python SDK timeline',
+        },
+        {
+            key: 'repo',
+            value: {
+                url: 'https://github.com/nfemmanuel/iranti',
+                visibility: 'private — flip to public at open source launch',
+                defaultBranch: 'main',
+                commitFormat: '[component] description',
+                branchFormat: 'feature/description or fix/description',
+            },
+            summary: 'GitHub repo nfemmanuel/iranti, private until open source launch',
+        },
+    ];
+    for (const fact of facts) {
+        const result = await iranti.write({
+            entity: 'codebase/iranti',
+            key: fact.key,
+            value: fact.value,
+            summary: fact.summary,
+            confidence: 100,
+            source: 'seed-codebase',
+            agent: 'system',
+        });
+        console.log(`  [${fact.key}] ${result.action}`);
+    }
+    await iranti.registerAgent({
+        agentId: 'system',
+        name: 'System',
+        description: 'Internal system agent for seeding and maintenance',
+        capabilities: ['seeding', 'maintenance', 'setup'],
+    });
+    console.log('  ✓ Codebase knowledge seeded');
+    process.exit(0);
+}
+seedCodebase().catch((err) => {
+    console.error('Codebase seed failed:', err);
+    process.exit(1);
+});
+//# sourceMappingURL=seed-codebase.js.map