@causyne/agent 0.0.0-stage → 1.10.1

package/src/sessionStore.js

@@ -0,0 +1,279 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import crypto from 'crypto';
+import { causyneHome } from './utils/paths.js';
+
+// Chat sessions. One conversation, one file, scoped to one workspace.
+//
+// WHAT THIS REPLACES, AND WHY IT HAD TO GO.
+//
+// There was exactly one `~/.causyne/memory/chat_history.json`. No id, no
+// workspace key, no time bound. Every invocation of Causyne, in every directory,
+// on every project, loaded the SAME conversation. So:
+//
+//   work on Causyne in ~/Causyne        -> history saved
+//   weeks later, open ~/Desktop/3d    -> the SAME history loads
+//   type "continue"                   -> the agent resumes the Causyne
+//                                        conversation, in the Blender directory,
+//                                        and goes scanning the old project
+//
+// That is not a memory feature working. It is one unbounded conversation
+// impersonating a memory, and it gets worse every day it is used: context from
+// months-old work leaks into today's task, and work from one client's project
+// leaks into another's.
+//
+// THE MODEL, taken from opencode's SessionV2.Info (id, projectID, title,
+// time.created/updated/archived): a session belongs to a WORKSPACE and is
+// resumed only when it is both the same workspace and recent. A different
+// directory is a different conversation. An old conversation in the same
+// directory is still there — listed, switchable — but it does not silently
+// become the thing "continue" continues.
+
+const SESSION_DIR = path.join(causyneHome(), 'sessions');
+const LEGACY_HISTORY = path.join(causyneHome(), 'memory', 'chat_history.json');
+const POINTER_FILE = path.join(SESSION_DIR, 'active.json');
+
+/**
+ * How long a session stays resumable in its own workspace.
+ *
+ * Past this, returning to the directory starts a NEW conversation rather than
+ * reviving one whose subject you have forgotten. The old one is still listed
+ * and can be resumed by name — the point is that it stops being the default.
+ */
+const RESUME_WINDOW_MS = 12 * 60 * 60 * 1000;
+
+/** Hard ceiling on retained sessions. The oldest are archived out first. */
+const MAX_SESSIONS = 50;
+
+function ensureDir() {
+  if (!fs.existsSync(SESSION_DIR)) fs.mkdirSync(SESSION_DIR, { recursive: true, mode: 0o700 });
+}
+
+/** A stable, filesystem-safe key for a workspace path. */
+function workspaceKey(workspace) {
+  return crypto.createHash('sha256').update(String(workspace || '')).digest('hex').slice(0, 12);
+}
+
+function sessionFile(id) {
+  const safe = String(id || '').replace(/[^a-zA-Z0-9_-]/g, '');
+  return path.join(SESSION_DIR, `${safe}.json`);
+}
+
+/**
+ * A short human title from the first thing the user actually asked for.
+ *
+ * `chat_history.json` had no title at all, which is why nothing could ever be
+ * listed or chosen. A session you cannot name is a session you cannot leave.
+ */
+export function titleFrom(text) {
+  const clean = String(text || '').replace(/\s+/g, ' ').trim();
+  if (!clean) return 'Untitled';
+  return clean.length > 60 ? clean.slice(0, 57) + '…' : clean;
+}
+
+function readSession(id) {
+  try {
+    const file = sessionFile(id);
+    if (!fs.existsSync(file)) return null;
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch (e) {
+    return null; // a corrupt session degrades to "no session", never to a crash
+  }
+}
+
+function writeSession(session) {
+  try {
+    ensureDir();
+    fs.writeFileSync(sessionFile(session.id), JSON.stringify(session, null, 2), { mode: 0o600 });
+    return true;
+  } catch (e) {
+    return false; // fail open: losing a session must not fail the task
+  }
+}
+
+/** Every session, newest first. Messages are NOT loaded — this is the index. */
+export function listSessions() {
+  try {
+    ensureDir();
+    const rows = [];
+    for (const name of fs.readdirSync(SESSION_DIR)) {
+      if (!name.endsWith('.json') || name === 'active.json') continue;
+      const session = readSession(name.replace(/\.json$/, ''));
+      if (!session) continue;
+      rows.push({
+        id: session.id,
+        title: session.title || 'Untitled',
+        workspace: session.workspace || '',
+        createdAt: session.createdAt || 0,
+        updatedAt: session.updatedAt || 0,
+        messageCount: Array.isArray(session.messages) ? session.messages.length : 0
+      });
+    }
+    return rows.sort((a, b) => b.updatedAt - a.updatedAt);
+  } catch (e) {
+    return [];
+  }
+}
+
+/**
+ * Retire the oldest sessions past MAX_SESSIONS.
+ *
+ * Called at session resolution rather than on a timer — nothing may run in the
+ * background (ZM-01), and a session boundary is often enough for a ceiling
+ * measured in dozens.
+ */
+export function pruneSessions(max = MAX_SESSIONS) {
+  try {
+    const all = listSessions();
+    let removed = 0;
+    for (const row of all.slice(max)) {
+      try { fs.unlinkSync(sessionFile(row.id)); removed++; } catch (e) { /* skip */ }
+    }
+    return removed;
+  } catch (e) {
+    return 0;
+  }
+}
+
+export function createSession(workspace, title = 'Untitled') {
+  const now = Date.now();
+  const session = {
+    id: `s_${now.toString(36)}_${crypto.randomBytes(3).toString('hex')}`,
+    workspace: String(workspace || ''),
+    workspaceKey: workspaceKey(workspace),
+    title,
+    createdAt: now,
+    updatedAt: now,
+    messages: []
+  };
+  writeSession(session);
+  setActiveSession(session.id);
+  pruneSessions();
+  return session;
+}
+
+export function getActiveSessionId() {
+  try {
+    if (!fs.existsSync(POINTER_FILE)) return null;
+    return JSON.parse(fs.readFileSync(POINTER_FILE, 'utf8')).id || null;
+  } catch (e) {
+    return null;
+  }
+}
+
+export function setActiveSession(id) {
+  try {
+    ensureDir();
+    fs.writeFileSync(POINTER_FILE, JSON.stringify({ id, at: Date.now() }, null, 2), { mode: 0o600 });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * The session this workspace should be using right now.
+ *
+ * THE RULE THAT FIXES THE BOOMERANG: resume only when the workspace matches AND
+ * the conversation is recent. Anything else starts fresh. A different directory
+ * is a different conversation, full stop.
+ *
+ * @param   {string} workspace  Usually process.cwd().
+ * @returns {object}            The session, with its messages loaded.
+ */
+export function resolveSession(workspace) {
+  ensureDir();
+  migrateLegacyHistory(workspace);
+
+  const key = workspaceKey(workspace);
+  const now = Date.now();
+
+  const candidate = listSessions()
+    .filter(row => row.workspace && workspaceKey(row.workspace) === key)
+    .find(row => now - row.updatedAt < RESUME_WINDOW_MS);
+
+  if (candidate) {
+    const session = readSession(candidate.id);
+    if (session) {
+      setActiveSession(session.id);
+      return session;
+    }
+  }
+
+  return createSession(workspace);
+}
+
+/** Load a specific session by id, making it active. */
+export function switchSession(id) {
+  const session = readSession(id);
+  if (!session) return null;
+  setActiveSession(session.id);
+  return session;
+}
+
+/** Persist a session's messages. Title is set once, from the first user turn. */
+export function saveSessionMessages(id, messages) {
+  const session = readSession(id);
+  if (!session) return false;
+
+  session.messages = Array.isArray(messages) ? messages : [];
+  session.updatedAt = Date.now();
+
+  if (!session.title || session.title === 'Untitled') {
+    const firstUser = session.messages.find(m => m.role === 'user' && typeof m.content === 'string');
+    if (firstUser) session.title = titleFrom(firstUser.content);
+  }
+
+  return writeSession(session);
+}
+
+export function deleteSession(id) {
+  try {
+    fs.unlinkSync(sessionFile(id));
+    if (getActiveSessionId() === id) setActiveSession(null);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Move the one global history into a session, once.
+ *
+ * Nothing is thrown away — the conversation that existed becomes a session
+ * belonging to the workspace it is first seen from, and the legacy file is
+ * renamed rather than deleted so it can be recovered if the migration is wrong.
+ */
+export function migrateLegacyHistory(workspace) {
+  try {
+    if (!fs.existsSync(LEGACY_HISTORY)) return null;
+
+    const raw = fs.readFileSync(LEGACY_HISTORY, 'utf8');
+    const messages = JSON.parse(raw);
+    if (!Array.isArray(messages) || messages.length === 0) {
+      fs.renameSync(LEGACY_HISTORY, LEGACY_HISTORY + '.migrated');
+      return null;
+    }
+
+    const firstUser = messages.find(m => m.role === 'user' && typeof m.content === 'string');
+    const session = createSession(workspace, titleFrom(firstUser ? firstUser.content : 'Imported conversation'));
+    session.messages = messages.filter(m => m.role !== 'system');
+    session.createdAt = fs.statSync(LEGACY_HISTORY).mtimeMs;
+    // NO WORKSPACE, deliberately. The legacy file belonged to every directory
+    // at once, so attaching it to whichever one happens to migrate it first
+    // would just recreate the boomerang somewhere arbitrary. It stays listed
+    // and switchable by name; it is never what `continue` continues.
+    session.workspace = '';
+    session.workspaceKey = '';
+    session.title = session.title === 'Untitled' ? 'Imported conversation' : session.title + ' (imported)';
+    writeSession(session);
+
+    fs.renameSync(LEGACY_HISTORY, LEGACY_HISTORY + '.migrated');
+    return session;
+  } catch (e) {
+    return null;
+  }
+}
+
+export { SESSION_DIR, RESUME_WINDOW_MS, MAX_SESSIONS };

package/src/skillsManager.js

@@ -0,0 +1,288 @@
+import fs from 'fs';
+import path from 'path';
+
+import { COMPILED_SKILLS } from './compiledSkills.js';
+import { loadUserSkills } from './userSkills.js';
+
+// User skills are read from disk, and the disk is slow relative to how often
+// these functions are called (every completion keystroke asks for the
+// catalogue). Cache for a moment so typing stays instant, but keep the window
+// short enough that a skill the agent just wrote shows up without a restart.
+const USER_CACHE_MS = 2000;
+let userCache = { at: 0, skills: [], problems: [] };
+
+export function invalidateUserSkills() {
+  userCache = { at: 0, skills: [], problems: [] };
+}
+
+function userSkills() {
+  const now = Date.now();
+  if (now - userCache.at < USER_CACHE_MS) return userCache;
+  try {
+    const loaded = loadUserSkills();
+    userCache = { at: now, skills: loaded.skills, problems: loaded.problems };
+  } catch (e) {
+    // A broken skills directory must never stop a session from starting.
+    userCache = { at: now, skills: [], problems: [`user skills unavailable: ${e.message}`] };
+  }
+  return userCache;
+}
+
+export function userSkillProblems() {
+  return userSkills().problems;
+}
+
+// What a workspace looks like from the outside.
+//
+// This used to name four domains, which meant that of the compiled skills only
+// android, web, python and devops could EVER be surfaced — every other one was
+// compiled into the artefact and unreachable. Detection is what decides whether
+// a skill exists as far as the model is concerned.
+//
+// Marker files only; no globbing and no directory walking, so detection stays a
+// handful of stat calls whatever the size of the repository.
+const DOMAIN_INDICATORS = {
+  android: ['build.gradle', 'build.gradle.kts', 'app/build.gradle', 'app/build.gradle.kts',
+            'app/src/main/AndroidManifest.xml', 'settings.gradle.kts', 'gradlew'],
+  mobile: ['pubspec.yaml', 'ios/Podfile', 'Podfile', 'app.json', 'metro.config.js',
+           'react-native.config.js', 'expo.json'],
+  web: ['next.config.js', 'next.config.mjs', 'next.config.ts', 'nuxt.config.ts',
+        'svelte.config.js', 'vue.config.js', 'astro.config.mjs', 'vite.config.js',
+        'vite.config.ts', 'angular.json', 'index.html', 'tailwind.config.js'],
+  backend: ['package.json', 'go.mod', 'Cargo.toml', 'pom.xml', 'build.sbt',
+            'Gemfile', 'composer.json', 'nest-cli.json'],
+  python: ['requirements.txt', 'pyproject.toml', 'Pipfile', 'setup.py', 'setup.cfg',
+           'uv.lock', 'poetry.lock', 'environment.yml'],
+  devops: ['Dockerfile', 'docker-compose.yml', 'docker-compose.yaml', '.github/workflows',
+           '.gitlab-ci.yml', 'Jenkinsfile', 'Makefile', '.circleci/config.yml'],
+  cloud: ['main.tf', 'terraform.tf', 'serverless.yml', 'template.yaml', 'Pulumi.yaml',
+          'cdk.json', 'k8s', 'kubernetes', 'helm', 'skaffold.yaml'],
+  database: ['prisma/schema.prisma', 'migrations', 'alembic.ini', 'knexfile.js',
+             'schema.sql', 'db/schema.rb', 'drizzle.config.ts', 'flyway.conf'],
+  testing: ['jest.config.js', 'jest.config.ts', 'vitest.config.ts', 'playwright.config.ts',
+            'cypress.config.js', 'pytest.ini', 'tox.ini', 'tests', 'test', '__tests__'],
+  security: ['.github/dependabot.yml', 'SECURITY.md', '.snyk', 'socket.yml', 'socket.json'],
+  design: ['tailwind.config.js', 'tailwind.config.ts', 'styles', 'src/styles',
+           'theme.js', 'theme.ts', 'tokens.json', 'postcss.config.js'],
+  // A 3D/video workspace. Without a rule here the media skills compile into
+  // the artefact and are unreachable by domain detection — tool_search still
+  // finds them, but the workspace never volunteers them.
+  media: ['.blend', 'assets/3d', 'renders', 'blender', 'shots', 'Resolve Projects'],
+  git: ['.git', '.gitignore', '.gitattributes'],
+  performance: ['lighthouserc.js', 'lighthouserc.json', '.lighthouserc.yml', 'k6.js',
+                'benchmark', 'benchmarks'],
+  'ai-engineering': ['.env.example', 'prompts', 'evals', 'langchain.json',
+                     'llm.config.js', 'openai.json'],
+  data: ['dbt_project.yml', 'airflow.cfg', 'dags', 'notebooks', '*.ipynb',
+         'dvc.yaml', 'great_expectations']
+};
+
+// Domains that apply to every task regardless of what the workspace looks like.
+//
+// Design and security are not properties of a file layout — an agent writing a
+// UI needs the anti-slop direction whether or not a tailwind config exists, and
+// input validation matters whether or not the repository has a SECURITY.md.
+const UNIVERSAL_DOMAINS = ['design', 'security'];
+
+// Ceiling on how many skill descriptions may enter the system prompt.
+//
+// With 100 skills, injecting every description of every detected domain would
+// spend thousands of tokens on an index before the task has even been read.
+// This is the progressive-disclosure contract: the model sees names and routing
+// conditions, and pulls a body with fs_read_skill only when one is relevant.
+const MAX_INDEXED_SKILLS = 40;
+
+export function detectWorkspaceDomains(workspaceRoot) {
+  if (!workspaceRoot || !fs.existsSync(workspaceRoot)) return UNIVERSAL_DOMAINS.slice();
+
+  const detectedDomains = [];
+
+  for (const [domain, indicators] of Object.entries(DOMAIN_INDICATORS)) {
+    for (const indicator of indicators) {
+      // A glob marker means "any file with this extension at the root". Kept to
+      // one readdir rather than a walk — a recursive search of a large monorepo
+      // on every task start is not worth one extra domain.
+      if (indicator.startsWith('*.')) {
+        try {
+          const extension = indicator.slice(1);
+          if (fs.readdirSync(workspaceRoot).some((name) => name.endsWith(extension))) {
+            detectedDomains.push(domain);
+            break;
+          }
+        } catch (e) { /* unreadable directory is simply not a match */ }
+        continue;
+      }
+      if (fs.existsSync(path.join(workspaceRoot, indicator))) {
+        detectedDomains.push(domain);
+        break;
+      }
+    }
+  }
+
+  for (const domain of UNIVERSAL_DOMAINS) {
+    if (!detectedDomains.includes(domain)) detectedDomains.push(domain);
+  }
+
+  return detectedDomains;
+}
+
+export { MAX_INDEXED_SKILLS, UNIVERSAL_DOMAINS };
+
+export function ensureSkillRepo(domain) {
+  
+  if (COMPILED_SKILLS[domain]) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * The index the model sees: names and routing conditions, never bodies.
+ *
+ * Progressive disclosure. 100 skills is roughly 250 KB of markdown; injecting it
+ * would consume the context window before the task was read. What goes in is one
+ * line per skill — the name and WHEN TO USE IT — and the model pulls the body
+ * with fs_read_skill only for the one it needs. This is the same contract
+ * claude-code and openclaw use, and it is what makes a large skill library
+ * possible at all.
+ *
+ * Capped at MAX_INDEXED_SKILLS. A workspace matching eight domains would
+ * otherwise inject fifty-odd descriptions; the detected domains come first so
+ * the cut falls on the least relevant.
+ */
+export function getUniversalSkillsIndex(domains) {
+  let indexText = '';
+  let totalSkillsCount = 0;
+
+  // One catalogue, so a user skill is as visible to the agent as a compiled one.
+  const catalogue = new Map();
+  for (const skill of listCompiledSkills()) {
+    if (!catalogue.has(skill.domain)) catalogue.set(skill.domain, []);
+    catalogue.get(skill.domain).push(skill);
+  }
+
+  // A user's own domains are always offered: someone who wrote a `team/` skill
+  // wants it considered, and no marker file in the workspace announces it.
+  const ownDomains = [...new Set(userSkills().skills.map((skill) => skill.domain))];
+  const wanted = [...new Set([...ownDomains, ...domains])];
+
+  for (const domain of wanted) {
+    const domainSkills = catalogue.get(domain);
+    if (!domainSkills || domainSkills.length === 0) continue;
+    if (totalSkillsCount >= MAX_INDEXED_SKILLS) break;
+
+    let domainSkillsCount = 0;
+    let domainIndexText = `### ${domain.toUpperCase()} SKILLS\n`;
+
+    for (const skill of domainSkills) {
+      if (totalSkillsCount + domainSkillsCount >= MAX_INDEXED_SKILLS) break;
+      const mark = skill.source === 'user' ? ' [your own]' : '';
+      domainIndexText += `- **${skill.name}**${mark} (ID: ${domain}/${skill.id}): ${skill.description}\n`;
+      domainSkillsCount++;
+    }
+
+    if (domainSkillsCount > 0) {
+      indexText += domainIndexText + '\n';
+      totalSkillsCount += domainSkillsCount;
+    }
+  }
+
+  if (totalSkillsCount === 0) return '';
+
+  let finalOutput = `\n<causyne_universal_skills>\n`;
+  finalOutput += `You have access to highly-curated, domain-specific intelligence skills provided as readable local skill data. If a skill is relevant to the user's task, you MUST use the \`fs_read_skill\` tool (passing the ID) to read its full instruction BEFORE proceeding with your plan. NEVER guess syntax if a skill exists for it.\n\n`;
+  finalOutput += indexText;
+  finalOutput += `</causyne_universal_skills>\n`;
+
+  return finalOutput;
+}
+
+/**
+ * The compact form of the skills index: what domains exist and how to search
+ * them, instead of forty name-and-description lines.
+ *
+ * WHY: `getUniversalSkillsIndex()` costs ~841 tokens for two domains and ~1,092
+ * for web+android, injected into a cached system block on EVERY request of
+ * EVERY task — a bare "hi" paid for a catalogue of skills it would never read.
+ *
+ * WHY IT IS SAFE NOW AND WAS NOT BEFORE: until `tool_search` learned to score
+ * the skill catalogue, this index was the ONLY way a model could discover a
+ * skill id. Shrinking it would have made 100 compiled skills unreachable —
+ * a capability regression wearing an optimisation's clothes. Retrieval replaces
+ * a catalogue only once the retrieval exists.
+ *
+ * @param   {Set|Array} domains  Workspace domains detected for this task.
+ * @returns {string}             System-prompt fragment, '' when nothing exists.
+ */
+export function getSkillDomainHeader(domains) {
+  const catalogue = new Map();
+  for (const skill of listCompiledSkills()) {
+    catalogue.set(skill.domain, (catalogue.get(skill.domain) || 0) + 1);
+  }
+  if (catalogue.size === 0) return '';
+
+  const total = [...catalogue.values()].reduce((sum, n) => sum + n, 0);
+  const relevant = [...new Set(domains || [])].filter(d => catalogue.has(d));
+  const all = [...catalogue.keys()].sort();
+
+  let out = `\n<causyne_universal_skills>\n`;
+  out += `${total} curated engineering skills are compiled into you, across: ${all.join(', ')}.\n`;
+  if (relevant.length > 0) {
+    out += `This workspace looks like: ${relevant.join(', ')}.\n`;
+  }
+  out += `Call \`tool_search\` with what you are trying to do to find the relevant skill ids, then read one with \`fs_read_skill\`. Do this BEFORE planning anything the skills cover. NEVER guess syntax a skill documents.\n`;
+  out += `</causyne_universal_skills>\n`;
+  return out;
+}
+
+/**
+ * The whole catalogue as a flat list, for the picker and for `/skills`.
+ *
+ * One shape for every consumer, so the terminal picker and the text listing can
+ * never disagree about what exists.
+ */
+export function listCompiledSkills() {
+  const out = [];
+  const seen = new Set();
+
+  // The user's own skills come first and SHADOW a compiled skill of the same
+  // id. That is the customisation: someone whose deployment genuinely differs
+  // from the shipped procedure writes their own `devops/zero-downtime-deploys`
+  // and theirs is the one the agent reads. Shipping a library that cannot be
+  // corrected is shipping an opinion.
+  for (const skill of userSkills().skills) {
+    const key = `${skill.domain}/${skill.id}`;
+    seen.add(key);
+    out.push({
+      domain: skill.domain, id: skill.id, name: skill.name,
+      description: skill.description, source: 'user'
+    });
+  }
+
+  for (const [domain, skills] of Object.entries(COMPILED_SKILLS)) {
+    for (const [id, data] of Object.entries(skills)) {
+      if (seen.has(`${domain}/${id}`)) continue;
+      out.push({
+        domain, id, name: data.name || id,
+        description: data.description || '', source: 'native'
+      });
+    }
+  }
+  return out;
+}
+
+export function readCompiledSkill(domain, skillId) {
+  // A user skill of the same id wins, for the same reason it does in the
+  // listing: the user's version is the corrected one.
+  const own = userSkills().skills
+    .find((skill) => skill.domain === domain && skill.id === skillId);
+  if (own) return own.content;
+
+  const domainSkills = COMPILED_SKILLS[domain];
+  if (!domainSkills) return `Error: Domain ${domain} not found in compiled skills.`;
+
+  const skillData = domainSkills[skillId];
+  if (!skillData) return `Error: Skill ${skillId} not found in domain ${domain}.`;
+
+  return skillData.content;
+}