@moskala/oneagent-core 0.1.0

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@moskala/oneagent-core",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Core library for oneagent — one source of truth for AI agent rules",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/moskalakamil/oneagent"
+  },
+  "module": "./src/index.ts",
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": [
+    "src",
+    "!src/__tests__"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "yaml": "^2"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5"
+  }
+}

package/src/config.ts

@@ -0,0 +1,19 @@
+import { parse, stringify } from "yaml";
+import path from "path";
+import type { Config } from "./types.ts";
+
+const CONFIG_REL = ".oneagent/config.yml";
+
+export async function configExists(root: string): Promise<boolean> {
+  return Bun.file(path.join(root, CONFIG_REL)).exists();
+}
+
+export async function readConfig(root: string): Promise<Config> {
+  const content = await Bun.file(path.join(root, CONFIG_REL)).text();
+  return parse(content) as Config;
+}
+
+export async function writeConfig(root: string, config: Config): Promise<void> {
+  const filePath = path.join(root, CONFIG_REL);
+  await Bun.write(filePath, stringify(config));
+}

package/src/copilot.ts

@@ -0,0 +1,21 @@
+import path from "path";
+import fs from "fs/promises";
+import type { RuleFile } from "./types.ts";
+
+export function buildCopilotContent(rule: RuleFile): string {
+  return `---\napplyTo: "${rule.applyTo}"\n---\n${rule.content}`;
+}
+
+export function copilotFilePath(root: string, ruleName: string): string {
+  return path.join(root, ".github/instructions", `${ruleName}.instructions.md`);
+}
+
+export async function generateCopilotRule(root: string, rule: RuleFile): Promise<void> {
+  const filePath = copilotFilePath(root, rule.name);
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await Bun.write(filePath, buildCopilotContent(rule));
+}
+
+export async function generateCopilotRules(root: string, rules: RuleFile[]): Promise<void> {
+  await Promise.all(rules.map((rule) => generateCopilotRule(root, rule)));
+}

package/src/detect.ts

@@ -0,0 +1,47 @@
+import path from "path";
+import fs from "fs/promises";
+import type { DetectedFile } from "./types.ts";
+
+export const AGENT_FILES = [
+  "CLAUDE.md",
+  "AGENTS.md",
+  ".cursorrules",
+  ".windsurfrules",
+  ".github/copilot-instructions.md",
+];
+
+export async function readDetectedFile(root: string, rel: string): Promise<DetectedFile | null> {
+  const absolutePath = path.join(root, rel);
+
+  try {
+    const stat = await fs.lstat(absolutePath);
+
+    if (stat.isSymbolicLink()) {
+      const linkTarget = await fs.readlink(absolutePath);
+      const resolved = path.resolve(path.dirname(absolutePath), linkTarget);
+      if (resolved.startsWith(path.join(root, ".one"))) return null;
+    }
+
+    const content = await Bun.file(absolutePath).text();
+    return {
+      relativePath: rel,
+      absolutePath,
+      sizeBytes: stat.size,
+      modifiedAt: stat.mtime,
+      content,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function detectExistingFiles(root: string): Promise<DetectedFile[]> {
+  const results = await Promise.all(AGENT_FILES.map((rel) => readDetectedFile(root, rel)));
+  return results.filter((f): f is DetectedFile => f !== null);
+}
+
+export function filesHaveSameContent(files: DetectedFile[]): boolean {
+  if (files.length <= 1) return true;
+  const first = files[0]!.content;
+  return files.every((f) => f.content === first);
+}

package/src/generate.ts

@@ -0,0 +1,21 @@
+import type { Config } from "./types.ts";
+import { readRules } from "./rules.ts";
+import { buildMainSymlinks, buildRulesSymlinks, createAllSymlinks } from "./symlinks.ts";
+import { generateCopilotRules } from "./copilot.ts";
+import { writeOpencode } from "./opencode.ts";
+
+export async function generate(root: string, config: Config): Promise<void> {
+  const rules = await readRules(root);
+
+  const mainSymlinks = buildMainSymlinks(root, config.targets);
+  const rulesSymlinks = buildRulesSymlinks(root, config.targets, rules);
+  await createAllSymlinks([...mainSymlinks, ...rulesSymlinks]);
+
+  if (config.targets.includes("copilot")) {
+    await generateCopilotRules(root, rules);
+  }
+
+  if (config.targets.includes("opencode")) {
+    await writeOpencode(root, rules);
+  }
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from "./types.ts";
+export * from "./config.ts";
+export * from "./detect.ts";
+export * from "./rules.ts";
+export * from "./symlinks.ts";
+export * from "./copilot.ts";
+export * from "./opencode.ts";
+export * from "./generate.ts";
+export * from "./status.ts";

package/src/opencode.ts

@@ -0,0 +1,24 @@
+import path from "path";
+import type { RuleFile } from "./types.ts";
+
+export async function readOpencode(root: string): Promise<Record<string, unknown> | null> {
+  try {
+    const content = await Bun.file(path.join(root, "opencode.json")).text();
+    return JSON.parse(content) as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+}
+
+export function buildOpencodeConfig(existing: Record<string, unknown> | null): object {
+  return {
+    ...existing,
+    instructions: ".oneagent/instructions.md",
+  };
+}
+
+export async function writeOpencode(root: string, _rules: RuleFile[]): Promise<void> {
+  const existing = await readOpencode(root);
+  const config = buildOpencodeConfig(existing);
+  await Bun.write(path.join(root, "opencode.json"), JSON.stringify(config, null, 2) + "\n");
+}

package/src/rules.ts

@@ -0,0 +1,34 @@
+import path from "path";
+import fs from "fs/promises";
+import type { RuleFile } from "./types.ts";
+
+export function parseFrontmatter(raw: string): { applyTo: string; content: string } {
+  const match = raw.match(/^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/);
+  if (!match) return { applyTo: "**", content: raw };
+
+  const frontmatter = match[1] ?? "";
+  const content = match[2] ?? "";
+
+  const applyToMatch = frontmatter.match(/applyTo:\s*["']?([^"'\n]+)["']?/);
+  const applyTo = applyToMatch?.[1]?.trim() ?? "**";
+
+  return { applyTo, content };
+}
+
+export async function readRuleFile(filePath: string): Promise<RuleFile> {
+  const raw = await Bun.file(filePath).text();
+  const { applyTo, content } = parseFrontmatter(raw);
+  return { name: path.basename(filePath, ".md"), path: filePath, applyTo, content };
+}
+
+export async function readRules(root: string): Promise<RuleFile[]> {
+  const rulesDir = path.join(root, ".oneagent/rules");
+  try {
+    const files = await fs.readdir(rulesDir);
+    const mdFiles = files.filter((f) => f.endsWith(".md"));
+    const rules = await Promise.all(mdFiles.map((f) => readRuleFile(path.join(rulesDir, f))));
+    return rules.sort((a, b) => a.name.localeCompare(b.name));
+  } catch {
+    return [];
+  }
+}

package/src/status.ts

@@ -0,0 +1,44 @@
+import type { Config, GeneratedFileCheck, OpenCodeCheck, RuleFile, StatusResult } from "./types.ts";
+import { readRules } from "./rules.ts";
+import { buildMainSymlinks, buildRulesSymlinks, checkSymlink } from "./symlinks.ts";
+import { buildCopilotContent, copilotFilePath } from "./copilot.ts";
+import { readOpencode } from "./opencode.ts";
+
+export async function checkGeneratedFile(root: string, rule: RuleFile): Promise<GeneratedFileCheck> {
+  const filePath = copilotFilePath(root, rule.name);
+  const expected = buildCopilotContent(rule);
+  try {
+    const content = await Bun.file(filePath).text();
+    return { path: filePath, exists: true, upToDate: content === expected };
+  } catch {
+    return { path: filePath, exists: false, upToDate: false };
+  }
+}
+
+export async function checkOpencodeStatus(
+  root: string,
+  _rules: RuleFile[],
+): Promise<OpenCodeCheck> {
+  const existing = await readOpencode(root);
+  if (!existing) return { exists: false, valid: false };
+  return { exists: true, valid: existing["instructions"] === ".oneagent/instructions.md" };
+}
+
+export async function checkStatus(root: string, config: Config): Promise<StatusResult> {
+  const rules = await readRules(root);
+
+  const allEntries = [
+    ...buildMainSymlinks(root, config.targets),
+    ...buildRulesSymlinks(root, config.targets, rules),
+  ];
+
+  const symlinks = await Promise.all(allEntries.map(checkSymlink));
+
+  const generatedFiles = config.targets.includes("copilot")
+    ? await Promise.all(rules.map((rule) => checkGeneratedFile(root, rule)))
+    : [];
+
+  const opencode = await checkOpencodeStatus(root, rules);
+
+  return { symlinks, generatedFiles, opencode };
+}

package/src/symlinks.ts

@@ -0,0 +1,116 @@
+import path from "path";
+import fs from "fs/promises";
+import type { AgentTarget, RuleFile, SymlinkCheck, SymlinkEntry } from "./types.ts";
+
+export async function ensureDir(dirPath: string): Promise<void> {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+
+export async function createSymlink(symlinkPath: string, target: string): Promise<void> {
+  await ensureDir(path.dirname(symlinkPath));
+  try {
+    await fs.unlink(symlinkPath);
+  } catch {
+    // file doesn't exist — that's fine
+  }
+  await fs.symlink(target, symlinkPath);
+}
+
+function relativeTarget(symlinkPath: string, targetAbsPath: string): string {
+  return path.relative(path.dirname(symlinkPath), targetAbsPath);
+}
+
+export function buildMainSymlinks(root: string, targets: AgentTarget[]): SymlinkEntry[] {
+  const instructionsAbs = path.join(root, ".oneagent/instructions.md");
+  const seen = new Map<string, SymlinkEntry>();
+
+  for (const target of targets) {
+    let symlinkPath: string;
+
+    switch (target) {
+      case "claude":
+        symlinkPath = path.join(root, "CLAUDE.md");
+        break;
+      case "cursor":
+        symlinkPath = path.join(root, "AGENTS.md");
+        break;
+      case "windsurf":
+        symlinkPath = path.join(root, ".windsurfrules");
+        break;
+      case "opencode":
+        symlinkPath = path.join(root, "AGENTS.md");
+        break;
+      case "copilot":
+        symlinkPath = path.join(root, ".github/copilot-instructions.md");
+        break;
+    }
+
+    if (!seen.has(symlinkPath)) {
+      seen.set(symlinkPath, {
+        symlinkPath,
+        target: relativeTarget(symlinkPath, instructionsAbs),
+        label: path.relative(root, symlinkPath),
+      });
+    }
+  }
+
+  return Array.from(seen.values());
+}
+
+export function buildRulesSymlinks(
+  root: string,
+  targets: AgentTarget[],
+  rules: RuleFile[],
+): SymlinkEntry[] {
+  const entries: SymlinkEntry[] = [];
+
+  for (const target of targets) {
+    let rulesDir: string | null = null;
+
+    switch (target) {
+      case "claude":
+        rulesDir = path.join(root, ".claude/rules");
+        break;
+      case "cursor":
+        rulesDir = path.join(root, ".cursor/rules");
+        break;
+      case "windsurf":
+        rulesDir = path.join(root, ".windsurf/rules");
+        break;
+      case "opencode":
+      case "copilot":
+        rulesDir = null;
+        break;
+    }
+
+    if (!rulesDir) continue;
+
+    for (const rule of rules) {
+      const symlinkPath = path.join(rulesDir, `${rule.name}.md`);
+      entries.push({
+        symlinkPath,
+        target: relativeTarget(symlinkPath, rule.path),
+        label: path.relative(root, symlinkPath),
+      });
+    }
+  }
+
+  return entries;
+}
+
+export async function createAllSymlinks(entries: SymlinkEntry[]): Promise<void> {
+  await Promise.all(entries.map((e) => createSymlink(e.symlinkPath, e.target)));
+}
+
+export async function checkSymlink(entry: SymlinkEntry): Promise<SymlinkCheck> {
+  try {
+    const stat = await fs.lstat(entry.symlinkPath);
+    if (!stat.isSymbolicLink()) {
+      return { ...entry, exists: true, valid: false };
+    }
+    const linkTarget = await fs.readlink(entry.symlinkPath);
+    return { ...entry, exists: true, valid: linkTarget === entry.target };
+  } catch {
+    return { ...entry, exists: false, valid: false };
+  }
+}

package/src/types.ts

@@ -0,0 +1,49 @@
+export type AgentTarget = "claude" | "cursor" | "windsurf" | "opencode" | "copilot";
+
+export interface Config {
+  version: 1;
+  targets: AgentTarget[];
+}
+
+export interface DetectedFile {
+  relativePath: string;
+  absolutePath: string;
+  sizeBytes: number;
+  modifiedAt: Date;
+  content: string;
+}
+
+export interface RuleFile {
+  name: string;
+  path: string;
+  applyTo: string;
+  content: string;
+}
+
+export interface SymlinkEntry {
+  symlinkPath: string;
+  target: string;
+  label: string;
+}
+
+export interface SymlinkCheck extends SymlinkEntry {
+  exists: boolean;
+  valid: boolean;
+}
+
+export interface StatusResult {
+  symlinks: SymlinkCheck[];
+  generatedFiles: GeneratedFileCheck[];
+  opencode: OpenCodeCheck;
+}
+
+export interface GeneratedFileCheck {
+  path: string;
+  exists: boolean;
+  upToDate: boolean;
+}
+
+export interface OpenCodeCheck {
+  exists: boolean;
+  valid: boolean;
+}