aspectcode 0.2.2 → 0.3.0

package/node_modules/@aspectcode/emitters/dist/emitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter.js","sourceRoot":"","sources":["../src/emitter.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG"}

package/node_modules/@aspectcode/emitters/dist/host.d.ts

@@ -0,0 +1,31 @@
+/**
+ * EmitterHost — abstraction for file I/O used by all emitters.
+ *
+ * The emitter layer MUST NOT depend on `vscode`. This interface lets
+ * emitters read/write files and query paths through a host that can be
+ * backed by Node.js `fs` (CLI) or VS Code workspace FS (extension).
+ */
+export interface EmitterHost {
+    /** Read a file as UTF-8 text. Throws if the file does not exist. */
+    readFile(filePath: string): Promise<string>;
+    /** Write UTF-8 text to a file, creating parent directories as needed. */
+    writeFile(filePath: string, content: string): Promise<void>;
+    /** Check whether a file or directory exists. */
+    exists(filePath: string): Promise<boolean>;
+    /** Recursively create directories (like `mkdir -p`). */
+    mkdirp(dirPath: string): Promise<void>;
+    /** Rename or move a file or directory. Must be same filesystem/drive. */
+    rename(fromPath: string, toPath: string): Promise<void>;
+    /** Remove a file or directory recursively (like `rm -rf`). */
+    rmrf(targetPath: string): Promise<void>;
+    /** Join path segments (platform-aware). */
+    join(...segments: string[]): string;
+    /** Return a relative path from `from` to `to` (forward-slash normalized). */
+    relative(from: string, to: string): string;
+}
+/**
+ * Create an EmitterHost backed by the Node.js `fs` module.
+ * Suitable for CLI usage and tests.
+ */
+export declare function createNodeEmitterHost(): EmitterHost;
+//# sourceMappingURL=host.d.ts.map

package/node_modules/@aspectcode/emitters/dist/host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../src/host.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAOH,MAAM,WAAW,WAAW;IAC1B,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAE5C,yEAAyE;IACzE,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE5D,gDAAgD;IAChD,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAE3C,wDAAwD;IACxD,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvC,yEAAyE;IACzE,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAExD,8DAA8D;IAC9D,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAExC,2CAA2C;IAC3C,IAAI,CAAC,GAAG,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;IAEpC,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;CAC5C;AAID;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,WAAW,CAwCnD"}

package/node_modules/@aspectcode/emitters/dist/host.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * EmitterHost — abstraction for file I/O used by all emitters.
+ *
+ * The emitter layer MUST NOT depend on `vscode`. This interface lets
+ * emitters read/write files and query paths through a host that can be
+ * backed by Node.js `fs` (CLI) or VS Code workspace FS (extension).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodeEmitterHost = createNodeEmitterHost;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// ── Node.js implementation ───────────────────────────────────
+/**
+ * Create an EmitterHost backed by the Node.js `fs` module.
+ * Suitable for CLI usage and tests.
+ */
+function createNodeEmitterHost() {
+    return {
+        async readFile(filePath) {
+            return fs.promises.readFile(filePath, 'utf-8');
+        },
+        async writeFile(filePath, content) {
+            await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+            await fs.promises.writeFile(filePath, content, 'utf-8');
+        },
+        async exists(filePath) {
+            try {
+                await fs.promises.access(filePath);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        async mkdirp(dirPath) {
+            await fs.promises.mkdir(dirPath, { recursive: true });
+        },
+        async rename(fromPath, toPath) {
+            await fs.promises.rename(fromPath, toPath);
+        },
+        async rmrf(targetPath) {
+            await fs.promises.rm(targetPath, { recursive: true, force: true });
+        },
+        join(...segments) {
+            return path.join(...segments);
+        },
+        relative(from, to) {
+            return path.relative(from, to).replace(/\\/g, '/');
+        },
+    };
+}
+//# sourceMappingURL=host.js.map

package/node_modules/@aspectcode/emitters/dist/host.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.js","sourceRoot":"","sources":["../src/host.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCH,sDAwCC;AA7ED,uCAAyB;AACzB,2CAA6B;AA8B7B,gEAAgE;AAEhE;;;GAGG;AACH,SAAgB,qBAAqB;IACnC,OAAO;QACL,KAAK,CAAC,QAAQ,CAAC,QAAgB;YAC7B,OAAO,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC;QAED,KAAK,CAAC,SAAS,CAAC,QAAgB,EAAE,OAAe;YAC/C,MAAM,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;YACrE,MAAM,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QAC1D,CAAC;QAED,KAAK,CAAC,MAAM,CAAC,QAAgB;YAC3B,IAAI,CAAC;gBACH,MAAM,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;gBACnC,OAAO,IAAI,CAAC;YACd,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,KAAK,CAAC;YACf,CAAC;QACH,CAAC;QAED,KAAK,CAAC,MAAM,CAAC,OAAe;YAC1B,MAAM,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACxD,CAAC;QAED,KAAK,CAAC,MAAM,CAAC,QAAgB,EAAE,MAAc;YAC3C,MAAM,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QAC7C,CAAC;QAED,KAAK,CAAC,IAAI,CAAC,UAAkB;YAC3B,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,UAAU,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QACrE,CAAC;QAED,IAAI,CAAC,GAAG,QAAkB;YACxB,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,CAAC;QAChC,CAAC;QAED,QAAQ,CAAC,IAAY,EAAE,EAAU;YAC/B,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QACrD,CAAC;KACF,CAAC;AACJ,CAAC"}

package/node_modules/@aspectcode/emitters/dist/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @aspectcode/emitters — public API surface.
+ *
+ * Artifact emitters that consume an AnalysisModel and write KB files,
+ * instruction files, and manifests. No vscode dependency.
+ */
+export type { EmitterHost } from './host';
+export { createNodeEmitterHost } from './host';
+export type { Emitter, EmitResult, EmitOptions, InstructionsMode, } from './emitter';
+export type { EmitReport } from './report';
+export type { Manifest, ManifestStats } from './manifest';
+export { buildManifest } from './manifest';
+export * from './kb';
+export { generateCanonicalContentForMode, generateCanonicalContentSafe, generateCanonicalContentPermissive, } from './instructions/content';
+export { createInstructionsEmitter } from './instructions/instructionsEmitter';
+export type { AiToolId } from './instructions/formats';
+export { AI_TOOL_DETECTION_PATHS } from './instructions/formats';
+import type { AnalysisModel } from '@aspectcode/core';
+import type { EmitterHost } from './host';
+import type { EmitOptions } from './emitter';
+import type { EmitReport } from './report';
+/**
+ * Run all built-in emitters in sequence.
+ * Returns the combined list of files written.
+ */
+export declare function runEmitters(model: AnalysisModel, host: EmitterHost, options: EmitOptions): Promise<EmitReport>;
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@aspectcode/emitters/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,YAAY,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,EAAE,qBAAqB,EAAE,MAAM,QAAQ,CAAC;AAI/C,YAAY,EACV,OAAO,EACP,UAAU,EACV,WAAW,EACX,gBAAgB,GACjB,MAAM,WAAW,CAAC;AAEnB,YAAY,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAI3C,YAAY,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAI3C,cAAc,MAAM,CAAC;AAIrB,OAAO,EACL,+BAA+B,EAC/B,4BAA4B,EAC5B,kCAAkC,GACnC,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AAE/E,YAAY,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAIjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAG3C;;;GAGG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,aAAa,EACpB,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,UAAU,CAAC,CAuDrB"}

package/node_modules/@aspectcode/emitters/dist/index.js

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * @aspectcode/emitters — public API surface.
+ *
+ * Artifact emitters that consume an AnalysisModel and write KB files,
+ * instruction files, and manifests. No vscode dependency.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AI_TOOL_DETECTION_PATHS = exports.createInstructionsEmitter = exports.generateCanonicalContentPermissive = exports.generateCanonicalContentSafe = exports.generateCanonicalContentForMode = exports.buildManifest = exports.createNodeEmitterHost = void 0;
+exports.runEmitters = runEmitters;
+var host_1 = require("./host");
+Object.defineProperty(exports, "createNodeEmitterHost", { enumerable: true, get: function () { return host_1.createNodeEmitterHost; } });
+var manifest_1 = require("./manifest");
+Object.defineProperty(exports, "buildManifest", { enumerable: true, get: function () { return manifest_1.buildManifest; } });
+// ── KB helpers ───────────────────────────────────────────────
+__exportStar(require("./kb"), exports);
+// ── Instructions ────────────────────────────────────────────
+var content_1 = require("./instructions/content");
+Object.defineProperty(exports, "generateCanonicalContentForMode", { enumerable: true, get: function () { return content_1.generateCanonicalContentForMode; } });
+Object.defineProperty(exports, "generateCanonicalContentSafe", { enumerable: true, get: function () { return content_1.generateCanonicalContentSafe; } });
+Object.defineProperty(exports, "generateCanonicalContentPermissive", { enumerable: true, get: function () { return content_1.generateCanonicalContentPermissive; } });
+var instructionsEmitter_1 = require("./instructions/instructionsEmitter");
+Object.defineProperty(exports, "createInstructionsEmitter", { enumerable: true, get: function () { return instructionsEmitter_1.createInstructionsEmitter; } });
+var formats_1 = require("./instructions/formats");
+Object.defineProperty(exports, "AI_TOOL_DETECTION_PATHS", { enumerable: true, get: function () { return formats_1.AI_TOOL_DETECTION_PATHS; } });
+const core_1 = require("@aspectcode/core");
+const transaction_1 = require("./transaction");
+/**
+ * Run all built-in emitters in sequence.
+ * Returns the combined list of files written.
+ */
+async function runEmitters(model, host, options) {
+    const _generatedAt = options.generatedAt ?? new Date().toISOString();
+    const outDir = options.outDir ?? options.workspaceRoot;
+    const opts = { ...options, generatedAt: _generatedAt, outDir };
+    const wrote = [];
+    const skipped = [];
+    // ── KB generation (opt-in) ────────────────────────────
+    if (opts.generateKb) {
+        const tx = new transaction_1.GenerationTransaction(host);
+        const txHost = tx.host;
+        const { createKBEmitter } = await Promise.resolve().then(() => __importStar(require('./kb/kbEmitter')));
+        const kb = createKBEmitter();
+        await kb.emit(model, txHost, opts);
+        await tx.commit();
+        wrote.push(...tx.getWrites().map((w) => ({ path: w.finalPath, bytes: w.bytes })));
+    }
+    else {
+        skipped.push({ id: 'kb', reason: 'KB generation not enabled (use --kb)' });
+    }
+    // ── Instructions (AGENTS.md — full file ownership) ─────────
+    if (opts.instructionsMode !== 'off') {
+        const { createInstructionsEmitter } = await Promise.resolve().then(() => __importStar(require('./instructions/instructionsEmitter')));
+        const instructions = createInstructionsEmitter();
+        const recordingHost = {
+            ...host,
+            writeFile: async (filePath, content) => {
+                const bytes = Buffer.byteLength(content, 'utf8');
+                await host.writeFile(filePath, content);
+                wrote.push({ path: filePath, bytes });
+            },
+        };
+        await instructions.emit(model, recordingHost, opts);
+    }
+    else {
+        skipped.push({ id: 'instructions', reason: 'Instructions mode is off' });
+    }
+    const stats = (0, core_1.computeModelStats)(model, 10);
+    return {
+        schemaVersion: model.schemaVersion,
+        wrote,
+        skipped: skipped.length > 0 ? skipped : undefined,
+        stats: {
+            files: stats.fileCount,
+            edges: stats.edgeCount,
+            hubsTop: stats.topHubs,
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

package/node_modules/@aspectcode/emitters/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDH,kCA2DC;AA3GD,+BAA+C;AAAtC,6GAAA,qBAAqB,OAAA;AAgB9B,uCAA2C;AAAlC,yGAAA,aAAa,OAAA;AAEtB,gEAAgE;AAEhE,uCAAqB;AAErB,+DAA+D;AAE/D,kDAIgC;AAH9B,0HAAA,+BAA+B,OAAA;AAC/B,uHAAA,4BAA4B,OAAA;AAC5B,6HAAA,kCAAkC,OAAA;AAGpC,0EAA+E;AAAtE,gIAAA,yBAAyB,OAAA;AAGlC,kDAAiE;AAAxD,kHAAA,uBAAuB,OAAA;AAKhC,2CAAqD;AAIrD,+CAAsD;AAEtD;;;GAGG;AACI,KAAK,UAAU,WAAW,CAC/B,KAAoB,EACpB,IAAiB,EACjB,OAAoB;IAEpB,MAAM,YAAY,GAChB,OAAO,CAAC,WAAW,IAAI,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IAClD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,aAAa,CAAC;IACvD,MAAM,IAAI,GAAgB,EAAE,GAAG,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC;IAE5E,MAAM,KAAK,GAA2C,EAAE,CAAC;IACzD,MAAM,OAAO,GAA0C,EAAE,CAAC;IAE1D,yDAAyD;IACzD,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;QACpB,MAAM,EAAE,GAAG,IAAI,mCAAqB,CAAC,IAAI,CAAC,CAAC;QAC3C,MAAM,MAAM,GAAG,EAAE,CAAC,IAAI,CAAC;QAEvB,MAAM,EAAE,eAAe,EAAE,GAAG,wDAAa,gBAAgB,GAAC,CAAC;QAC3D,MAAM,EAAE,GAAG,eAAe,EAAE,CAAC;QAC7B,MAAM,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;QAEnC,MAAM,EAAE,CAAC,MAAM,EAAE,CAAC;QAClB,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,SAAS,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;IACpF,CAAC;SAAM,CAAC;QACN,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,sCAAsC,EAAE,CAAC,CAAC;IAC7E,CAAC;IAED,8DAA8D;IAC9D,IAAI,IAAI,CAAC,gBAAgB,KAAK,KAAK,EAAE,CAAC;QACpC,MAAM,EAAE,yBAAyB,EAAE,GAAG,wDAAa,oCAAoC,GAAC,CAAC;QACzF,MAAM,YAAY,GAAG,yBAAyB,EAAE,CAAC;QAEjD,MAAM,aAAa,GAAgB;YACjC,GAAG,IAAI;YACP,SAAS,EAAE,KAAK,EAAE,QAAgB,EAAE,OAAe,EAAE,EAAE;gBACrD,MAAM,KAAK,GAAG,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;gBACjD,MAAM,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;gBACxC,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC;YACxC,CAAC;SACF,CAAC;QAEF,MAAM,YAAY,CAAC,IAAI,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,CAAC;IACtD,CAAC;SAAM,CAAC;QACN,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,cAAc,EAAE,MAAM,EAAE,0BAA0B,EAAE,CAAC,CAAC;IAC3E,CAAC;IAED,MAAM,KAAK,GAAG,IAAA,wBAAiB,EAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAE3C,OAAO;QACL,aAAa,EAAE,KAAK,CAAC,aAAa;QAClC,KAAK;QACL,OAAO,EAAE,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS;QACjD,KAAK,EAAE;YACL,KAAK,EAAE,KAAK,CAAC,SAAS;YACtB,KAAK,EAAE,KAAK,CAAC,SAAS;YACtB,OAAO,EAAE,KAAK,CAAC,OAAO;SACvB;KACF,CAAC;AACJ,CAAC"}

package/node_modules/@aspectcode/emitters/dist/instructions/content.d.ts

@@ -0,0 +1,15 @@
+import type { InstructionsMode } from '../emitter';
+/**
+ * Generates the canonical instruction content.
+ *
+ * When `kbAvailable` is true, the content references the `kb.md` knowledge
+ * base file. When false, it provides standalone rules and guidelines only.
+ *
+ * All assistant-specific exports are derived from this single source.
+ */
+export declare function generateCanonicalContentForMode(mode: InstructionsMode, kbAvailable?: boolean): string;
+export declare function generateCanonicalContentSafe(): string;
+export declare function generateCanonicalContentPermissive(): string;
+export declare function generateCanonicalContentSafeKB(): string;
+export declare function generateCanonicalContentPermissiveKB(): string;
+//# sourceMappingURL=content.d.ts.map

package/node_modules/@aspectcode/emitters/dist/instructions/content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../src/instructions/content.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAUnD;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,gBAAgB,EACtB,WAAW,UAAQ,GAClB,MAAM,CAOR;AAMD,wBAAgB,4BAA4B,IAAI,MAAM,CAsDrD;AAED,wBAAgB,kCAAkC,IAAI,MAAM,CA4C3D;AAMD,wBAAgB,8BAA8B,IAAI,MAAM,CAkGvD;AAED,wBAAgB,oCAAoC,IAAI,MAAM,CAoD7D"}

package/node_modules/@aspectcode/emitters/dist/instructions/content.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCanonicalContentForMode = generateCanonicalContentForMode;
+exports.generateCanonicalContentSafe = generateCanonicalContentSafe;
+exports.generateCanonicalContentPermissive = generateCanonicalContentPermissive;
+exports.generateCanonicalContentSafeKB = generateCanonicalContentSafeKB;
+exports.generateCanonicalContentPermissiveKB = generateCanonicalContentPermissiveKB;
+// ─────────────────────────────────────────────────────────────────────────────
+// Canonical instruction content - all exports derive from this
+//
+// Two tiers:
+//   1. Rules-only (no KB references) — default when kb.md is not generated
+//   2. KB-aware (references kb.md) — used when generateKb is enabled
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Generates the canonical instruction content.
+ *
+ * When `kbAvailable` is true, the content references the `kb.md` knowledge
+ * base file. When false, it provides standalone rules and guidelines only.
+ *
+ * All assistant-specific exports are derived from this single source.
+ */
+function generateCanonicalContentForMode(mode, kbAvailable = false) {
+    if (mode === 'permissive') {
+        return kbAvailable
+            ? generateCanonicalContentPermissiveKB()
+            : generateCanonicalContentPermissive();
+    }
+    return kbAvailable ? generateCanonicalContentSafeKB() : generateCanonicalContentSafe();
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Rules-only content (no KB references)
+// ─────────────────────────────────────────────────────────────────────────────
+function generateCanonicalContentSafe() {
+    return `## Aspect Code — Coding Guidelines
+
+**Aspect Code** provides coding guidelines to help you make safer, more informed code changes.
+
+## Golden Rules
+
+1. **Read before you write.** Open and read the relevant files before multi-file edits.
+2. **Think step-by-step.** Break complex tasks into smaller steps; reason through each before coding.
+3. **Prefer minimal, local changes.** Small patches are safer than large refactors, especially in widely-imported files.
+4. **Never truncate code.** Don't use placeholders like \`// ...rest\` or \`# existing code...\`. Provide complete implementations.
+5. **Don't touch tests, migrations, or third-party code** unless the user explicitly asks you to.
+6. **Never remove referenced logic.** Check all callers before deleting a function, class, or symbol.
+7. **Understand blast radius.** Trace relationships and dependents before refactoring.
+8. **Follow existing naming patterns.** Match the project's existing naming patterns and import styles.
+9. **When unsure, go small.** Propose a minimal, reversible change instead of a sweeping refactor.
+
+## Recommended Workflow
+
+1. **Understand the task.** Parse requirements; note which files or endpoints are involved.
+2. **Find relevant code.** Locate data models, symbols, and naming conventions.
+3. **Understand relationships.** See which files are commonly edited together and how they connect.
+4. **Trace impact.** Review callers and dependents to gauge the blast radius of changes.
+5. **Gather evidence.** If behavior is unclear, add targeted logging or traces to confirm assumptions.
+6. **Make minimal edits.** Implement the smallest change that solves the task; run tests.
+
+## When Changing Code
+
+- **Read the COMPLETE file** before modifying it. Preserve all existing exports/functions.
+- **Add, don't reorganize.** Unless the task says "refactor", avoid moving code around.
+- **Check widely-imported files** before editing them — changes ripple to all dependents.
+- **Avoid renaming** widely-used symbols without updating all callers.
+- **No new dependency cycles.** Before adding an import, verify it won't create a circular dependency.
+- **Match conventions.** Follow existing naming patterns (naming, imports, frameworks).
+- **Prefer small, localized changes** in the most relevant module.
+
+## When Things Go Wrong
+
+If you encounter repeated errors or unexpected behavior:
+
+1. **Use git** to see what changed: \`git diff\`, \`git status\`
+2. **Restore lost code** with \`git checkout -- <file>\` if needed
+3. **Re-read the complete file** before making more changes
+4. **Trace data flows** to understand execution paths
+5. **Run actual tests** to verify behavior before assuming something works
+
+## General Guidelines
+
+- **Start with the most relevant file.** Understand the area before changing it.
+- **Check widely-imported modules.** Know which files have many dependents before editing.
+- **Follow existing conventions.** Match existing naming patterns and coding styles exactly.
+- **Minimal changes.** Make the smallest change that solves the problem correctly.
+- **Acknowledge risk.** If editing a widely-imported file, note the elevated risk.
+`.trim();
+}
+function generateCanonicalContentPermissive() {
+    return `## Aspect Code — Coding Guidelines
+
+**Aspect Code** provides coding guidelines to help you make informed code changes.
+
+Use these guidelines as orientation — not as constraints.
+
+### Operating Rules (Pragmatic, Not Rigid)
+
+- Read relevant code before large edits; understand boundaries, flows, and ownership
+- If your change creates a conflict with existing structure, either:
+  - update the code in a way that keeps the existing intent valid, or
+  - explicitly state the mismatch and proceed with a coherent new structure
+
+### You May (Explicitly Allowed)
+
+- Refactor for clarity: extract functions, split files, consolidate duplicates
+- Reorganize modules/folders when it improves cohesion and discoverability
+- Touch multiple files when the change is conceptually one improvement
+- Change public/internal APIs when it simplifies the design (with follow-through updates)
+- Rename symbols for consistency (types, functions, modules) and update references
+
+### You Should
+
+- Explain the new structure in terms of the existing architecture
+- Keep changes "conceptually tight": one goal, end-to-end, fully wired
+- Update call sites and imports immediately when you move/rename things
+- Prefer simplification over novelty; remove unnecessary layers when justified
+- Validate that referenced symbols still exist and are still reachable from call sites
+
+### Avoid
+
+- Deleting or renaming referenced symbols without updating all usages
+- Unnecessary scope creep (adding features unrelated to the request)
+- Blind rewrites that ignore the project's dependency structure and entry points
+- "Rebuild everything" refactors when a targeted restructure achieves the goal
+- Cosmetic churn that obscures meaningful changes
+
+## Suggested Workflow
+
+1. Read the relevant code for orientation.
+2. Implement the change end-to-end.
+3. Run tests / build.
+`.trim();
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// KB-aware content (references kb.md)
+// ─────────────────────────────────────────────────────────────────────────────
+function generateCanonicalContentSafeKB() {
+    return `## Aspect Code Knowledge Base
+
+**Aspect Code** is a static-analysis tool that generates a Knowledge Base (KB) for your codebase. The KB is in \`kb.md\` at the workspace root and contains these sections:
+
+| Section | Purpose |
+|---------|---------|
+| **Architecture** | **Read first.** High-risk hubs, directory layout, entry points—the "Do Not Break" zones |
+| **Map** | Data models with signatures, symbol index, naming conventions |
+| **Context** | Module clusters (co-edited files), external integrations, data flow paths |
+
+**Key architectural intelligence:**
+- **High-Risk Hubs** in the Architecture section: Files with many dependents—changes here ripple widely
+- **Entry Points** in the Architecture section: HTTP handlers, CLI commands, event listeners
+- **External Integrations** in the Context section: API clients, database connections, message queues
+- **Data Models** in the Map section: ORM models, dataclasses, TypeScript interfaces with signatures
+
+Read the relevant sections of \`kb.md\` **before** making multi-file changes.
+
+## Golden Rules
+
+1. **Read the KB as a map, not a checklist.** Use \`kb.md\` to understand architecture, not as a to-do list.
+2. **Read before you write.** Open the relevant KB sections before multi-file edits.
+3. **Check architecture first.** Review the Architecture section to understand high-risk zones before coding.
+4. **Think step-by-step.** Break complex tasks into smaller steps; reason through each before coding.
+5. **Prefer minimal, local changes.** Small patches are safer than large refactors, especially in hub files.
+6. **Never truncate code.** Don't use placeholders like \`// ...rest\` or \`# existing code...\`. Provide complete implementations.
+7. **Don't touch tests, migrations, or third-party code** unless the user explicitly asks you to.
+8. **Never remove referenced logic.** If a symbol appears in the Map section, check all callers before deleting.
+9. **Understand blast radius.** Use the Context and Map sections to trace relationships before refactors.
+10. **Follow naming patterns in the Map section.** Match the project's existing naming patterns and import styles.
+11. **When unsure, go small.** Propose a minimal, reversible change instead of a sweeping refactor.
+
+## Recommended Workflow
+
+1. **Understand the task.** Parse requirements; note which files or endpoints are involved.
+2. **Check architecture.** Open \`kb.md\` → review the Architecture section for high-risk hubs and entry points.
+3. **Find relevant code.** Review the Map section → locate data models, symbols, and naming conventions.
+4. **Understand relationships.** Review the Context section → see module clusters (co-edited files) and integrations.
+5. **Trace impact.** Review "Called by" in the Map section to gauge the blast radius of changes.
+6. **Gather evidence.** If behavior is unclear, add targeted logging or traces to confirm assumptions.
+7. **Make minimal edits.** Implement the smallest change that solves the task; run tests.
+
+## When Changing Code
+
+- **Read the COMPLETE file** before modifying it. Preserve all existing exports/functions.
+- **Add, don't reorganize.** Unless the task says "refactor", avoid moving code around.
+- **Check high-risk hubs** (Architecture section) before editing widely-imported files.
+- **Avoid renaming** widely-used symbols listed in the Map section without updating all callers.
+- **No new cycles.** Before adding an import, verify it won't create a circular dependency (Architecture section).
+- **Match conventions.** Follow naming patterns shown in the Map section (naming, imports, frameworks).
+- **Check module clusters** (Context section) to understand which files are commonly edited together.
+- **Prefer small, localized changes** in the most relevant app module identified by the KB.
+- **Use the Architecture, Map, and Context sections** to locate the smallest, safest place to make a change.
+
+## How to Use kb.md
+
+| Section | When to Open | What to Look For |
+|---------|--------------|------------------|
+| Architecture | **First, always** | High-risk hubs, directory layout, entry points, circular dependencies |
+| Map | Before modifying a function | Data models with signatures, symbol index, naming conventions |
+| Context | Before architectural changes | Module clusters, external integrations, data flow patterns |
+
+### Quick Reference
+
+- **High-risk hubs** → Files with 3+ dependents listed in the Architecture section—changes ripple widely
+- **Entry points** → HTTP handlers, CLI commands, event listeners in the Architecture section
+- **External integrations** → HTTP clients, DB connections, message queues in the Context section
+- **Data models** → ORM models, dataclasses, interfaces with signatures in the Map section
+- **Module clusters** → Files commonly edited together in the Context section
+- **High-impact symbol** → 5+ callers in the Map section "Called by" column
+
+## When Things Go Wrong
+
+If you encounter repeated errors or unexpected behavior:
+
+1. **Use git** to see what changed: \`git diff\`, \`git status\`
+2. **Restore lost code** with \`git checkout -- <file>\` if needed
+3. **Re-read the complete file** before making more changes
+4. **Trace data flows** using the Context section to understand execution paths
+5. **Run actual tests** to verify behavior before assuming something works
+6. **Check module clusters** in the Context section for related files that may need updates
+
+## General Guidelines
+
+- **Read kb.md first.** Before making changes, consult the relevant knowledge base sections.
+- **Start with the Architecture section.** Understand high-risk hubs and entry points.
+- **Check hub modules.** Know which files have many dependents before editing.
+- **Follow Map section conventions.** Match existing naming patterns and coding styles exactly.
+- **Minimal changes.** Make the smallest change that solves the problem correctly.
+- **Acknowledge risk.** If editing a hub module or high-impact file, note the elevated risk.
+
+## Section Headers (Pattern-Matching)
+
+**Architecture:** \`## High-Risk Architectural Hubs\`, \`## Directory Layout\`, \`## Entry Points\`, \`## Circular Dependencies\`
+**Map:** \`## Data Models\` (with signatures), \`## Symbol Index\` (with Called By), \`## Conventions\`
+**Context:** \`## Module Clusters\` (co-edited files), \`## External Integrations\`, \`## Critical Flows\`
+`.trim();
+}
+function generateCanonicalContentPermissiveKB() {
+    return `## Aspect Code Knowledge Base
+
+**Aspect Code** is a static-analysis tool that generates a Knowledge Base (KB) for your codebase. The KB is in \`kb.md\` at the workspace root and contains these sections:
+
+| Section | Purpose |
+|---------|---------|
+| **Architecture** | Hubs, directory layout, entry points |
+| **Map** | Data models with signatures, symbol index, naming conventions |
+| **Context** | Module clusters (co-edited files), external integrations, data flow paths |
+
+Use the Knowledge Base (KB) as orientation and ground truth for architecture and dependencies—not as a constraint.
+
+### Operating Rules (KB-First, Not KB-Locked)
+
+- Read \`kb.md\` before large edits; use it to understand boundaries, flows, and ownership
+- Treat the KB as the source of "what connects to what" (entry points, hubs, key types)
+- If your change conflicts with the KB, either:
+  - update the code in a way that keeps the KB's intent valid, or
+  - explicitly state the mismatch and proceed with a coherent new structure
+
+### You May (Explicitly Allowed)
+
+- Refactor for clarity: extract functions, split files, consolidate duplicates
+- Reorganize modules/folders when it improves cohesion and discoverability
+- Touch multiple files when the change is conceptually one improvement
+- Change public/internal APIs when it simplifies the design (with follow-through updates)
+- Edit high-risk hubs when needed—do it deliberately, with dependency awareness
+- Rename symbols for consistency (types, functions, modules) and update references
+
+### You Should
+
+- Explain the new structure in terms of the existing architecture
+- Keep changes "conceptually tight": one goal, end-to-end, fully wired
+- Update call sites and imports immediately when you move/rename things
+- Prefer simplification over novelty; remove unnecessary layers when justified
+- Validate that referenced symbols still exist and are still reachable from call sites
+
+### Avoid
+
+- Deleting or renaming referenced symbols without updating all usages
+- Unnecessary scope creep (adding features unrelated to the request)
+- Blind rewrites that ignore \`kb.md\`'s dependency map and entry points
+- "Rebuild everything" refactors when a targeted restructure achieves the goal
+- Cosmetic churn that obscures meaningful changes
+
+## Suggested Workflow
+
+1. Skim the relevant sections of \`kb.md\` for orientation.
+2. Implement the change end-to-end.
+3. Run tests / build.
+`.trim();
+}
+//# sourceMappingURL=content.js.map

package/node_modules/@aspectcode/emitters/dist/instructions/content.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.js","sourceRoot":"","sources":["../../src/instructions/content.ts"],"names":[],"mappings":";;AAkBA,0EAUC;AAMD,oEAsDC;AAED,gFA4CC;AAMD,wEAkGC;AAED,oFAoDC;AAlSD,gFAAgF;AAChF,+DAA+D;AAC/D,EAAE;AACF,aAAa;AACb,2EAA2E;AAC3E,qEAAqE;AACrE,gFAAgF;AAEhF;;;;;;;GAOG;AACH,SAAgB,+BAA+B,CAC7C,IAAsB,EACtB,WAAW,GAAG,KAAK;IAEnB,IAAI,IAAI,KAAK,YAAY,EAAE,CAAC;QAC1B,OAAO,WAAW;YAChB,CAAC,CAAC,oCAAoC,EAAE;YACxC,CAAC,CAAC,kCAAkC,EAAE,CAAC;IAC3C,CAAC;IACD,OAAO,WAAW,CAAC,CAAC,CAAC,8BAA8B,EAAE,CAAC,CAAC,CAAC,4BAA4B,EAAE,CAAC;AACzF,CAAC;AAED,gFAAgF;AAChF,wCAAwC;AACxC,gFAAgF;AAEhF,SAAgB,4BAA4B;IAC1C,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDR,CAAC,IAAI,EAAE,CAAC;AACT,CAAC;AAED,SAAgB,kCAAkC;IAChD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CR,CAAC,IAAI,EAAE,CAAC;AACT,CAAC;AAED,gFAAgF;AAChF,sCAAsC;AACtC,gFAAgF;AAEhF,SAAgB,8BAA8B;IAC5C,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgGR,CAAC,IAAI,EAAE,CAAC;AACT,CAAC;AAED,SAAgB,oCAAoC;IAClD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDR,CAAC,IAAI,EAAE,CAAC;AACT,CAAC"}

package/node_modules/@aspectcode/emitters/dist/instructions/detection.d.ts

@@ -0,0 +1,13 @@
+import type { EmitterHost } from '../host';
+import type { AiToolId } from './formats';
+export type AssistantId = 'aspectKB' | 'agentsMd';
+/**
+ * Detects which Aspect Code artifacts exist (KB, instructions).
+ */
+export declare function detectAssistants(host: EmitterHost, workspaceRoot: string): Promise<Set<AssistantId>>;
+/**
+ * Detects which AI coding tools are present in the workspace by checking
+ * for their config/instruction files on disk.
+ */
+export declare function detectAiTools(host: EmitterHost, workspaceRoot: string): Promise<Set<AiToolId>>;
+//# sourceMappingURL=detection.d.ts.map

package/node_modules/@aspectcode/emitters/dist/instructions/detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detection.d.ts","sourceRoot":"","sources":["../../src/instructions/detection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAK1C,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,UAAU,CAAC;AAOlD;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,WAAW,EACjB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAuB3B;AAED;;;GAGG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,WAAW,EACjB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAuBxB"}