yamtam-core 0.1.0

package/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "yamtam-core",
+  "version": "0.1.0",
+  "description": "YAMTAM core — Router · Safety · Context. Powers Yana and any interface built on YAMTAM.",
+  "main": "src/index.js",
+  "type": "commonjs",
+  "engines": { "node": ">=18" },
+  "keywords": ["yamtam", "yana", "ai-router", "skill-matching", "agent"],
+  "license": "MIT"
+}

package/src/agents.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const MAX_PROMPT_BYTES  = 8 * 1024;
+const TRUNCATION_MARKER = '\n\n[...system prompt truncated at 8 KB...]';
+
+const GENERIC_PROMPT = `Tên mình là Yana — lớp giao tiếp chính của YAMTAM. Senior engineer luôn online, không có kiên nhẫn với câu trả lời mơ hồ.
+
+Giọng nói:
+- Nói như engineer đang pair-programming với đồng nghiệp — không phải agent AI "hỗ trợ khách hàng"
+- Tuyệt đối không: "Certainly!", "Of course!", "Great question!", "Sure!", "Absolutely!", "I'd be happy to help!"
+- Không mở đầu bằng lời khen câu hỏi. Không kết thúc bằng "Is there anything else?"
+- Đi thẳng vào vấn đề. Ngắn hơn là tốt hơn, trừ khi cần giải thích kỹ
+
+Tính cách:
+- Kiên định về craft — không viết code xấu để lấy lòng, nói thẳng khi có vấn đề rồi đề xuất cách tốt hơn
+- Thực dụng — giải quyết vấn đề thực tế trước, refactor sau
+- Bảo vệ — cảnh báo trước các action irreversible (force push, xóa data, deploy prod)
+- Không hallucinate — nếu không chắc thì nói "không chắc", không bịa câu trả lời nghe có vẻ đúng
+- Hài hước đúng lúc — có humor nhưng không force, không meme khi đang debug production
+
+Code:
+- Viết ngôn ngữ/framework người dùng đang dùng — không tự switch stack
+- Show diff khi có thể, không dump cả file
+- Fix bug trước, giải thích sau
+- Typed, error-handled, không có any trừ khi bắt buộc
+
+Ngôn ngữ:
+- Reply bằng ngôn ngữ người dùng viết
+- Mix tiếng Việt + tiếng Anh → follow theo, không normalize
+- Không dịch code comments hay variable names trừ khi được hỏi`;
+
+/**
+ * createAgents({ agentsDir }) → { loadSystemPrompt }
+ */
+function createAgents({ agentsDir } = {}) {
+  const AGENTS_DIR = agentsDir || '';
+
+  function stripFrontmatter(content) {
+    const lines = content.split('\n');
+    if (lines[0].trim() !== '---') return content;
+    const closeIdx = lines.findIndex((l, i) => i > 0 && l.trim() === '---');
+    return closeIdx < 0 ? content : lines.slice(closeIdx + 1).join('\n').trim();
+  }
+
+  function tryLoadAgent(name) {
+    if (!AGENTS_DIR || !/^[a-zA-Z0-9_-]+$/.test(name)) return null;
+    try {
+      const raw = fs.readFileSync(path.join(AGENTS_DIR, name + '.md'), 'utf8');
+      return stripFrontmatter(raw);
+    } catch (_) { return null; }
+  }
+
+  function capPrompt(text) {
+    const buf = Buffer.from(text, 'utf8');
+    if (buf.length <= MAX_PROMPT_BYTES) return text;
+    const marker = Buffer.from(TRUNCATION_MARKER, 'utf8');
+    return buf.slice(0, MAX_PROMPT_BYTES - marker.length).toString('utf8') + TRUNCATION_MARKER;
+  }
+
+  function loadSystemPrompt(suggestedAgents) {
+    if (Array.isArray(suggestedAgents)) {
+      for (const name of suggestedAgents) {
+        if (typeof name !== 'string') continue;
+        const body = tryLoadAgent(name.trim());
+        if (body && body.length > 0) return capPrompt(body);
+      }
+    }
+    return GENERIC_PROMPT;
+  }
+
+  return { loadSystemPrompt };
+}
+
+module.exports = { createAgents };

package/src/classifier.js

@@ -0,0 +1,296 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const EXTERNAL_SIGNALS = [
+  'git push', 'cargo publish', 'npm publish', 'deploy',
+  'send email', 'send message', 'rm -rf', 'production',
+  'kubectl apply', 'terraform apply',
+];
+
+const COMPLEX_SIGNALS = [
+  'implement', 'refactor', 'sửa bug', 'fix bug',
+  'add feature', 'create', 'build', 'migrate',
+  'test', 'debug',
+];
+
+// Learning signals → route to hoc-tap agent
+const LEARNING_SIGNALS = [
+  'giải thích', 'explain', 'học', 'hiểu', 'tại sao', 'why is',
+  'how does', 'hoạt động như thế nào', 'là gì', 'what is',
+  'ví dụ về', 'example of', 'dạy tôi', 'teach me',
+  'tóm tắt bài', 'summarize this article', 'ôn tập',
+  'bài tập', 'exercise', 'quiz', 'kiểm tra kiến thức',
+];
+
+// Daily work signals → route to daily-assistant agent
+const DAILY_SIGNALS = [
+  'tóm tắt', 'summarize', 'soạn email', 'write email', 'viết email',
+  'lên kế hoạch', 'plan', 'todo', 'danh sách việc', 'task list',
+  'nhắc tôi', 'remind me', 'lịch', 'schedule',
+  'phân tích', 'analyze this', 'pros cons', 'so sánh',
+  'soạn thảo', 'draft', 'báo cáo', 'report',
+];
+
+// Creative writing signals → route to creative-writer agent
+const CREATIVE_SIGNALS = [
+  'viết bài', 'bài viết', 'blog', 'content', 'copywriting',
+  'sáng tác', 'kịch bản', 'story', 'câu chuyện', 'tiểu thuyết',
+  'thông điệp', 'slogan', 'tagline', 'quảng cáo', 'ad copy',
+  'caption', 'mô tả sản phẩm', 'product description',
+  'lời giới thiệu', 'introduction text', 'about us',
+  'viết lại', 'rewrite', 'paraphrase',
+];
+
+// Data analysis signals → route to data-analyst agent
+const DATA_SIGNALS = [
+  'phân tích dữ liệu', 'data analysis', 'dataset',
+  'sql', 'query', 'select from', 'join',
+  'excel', 'csv', 'pandas', 'dataframe', 'matplotlib',
+  'thống kê', 'statistics', 'biểu đồ', 'chart', 'dashboard',
+  'eda', 'exploratory', 'histogram', 'correlation',
+  'machine learning', 'model training', 'feature',
+];
+
+// Review / audit signals → route to reviewer agents
+const REVIEW_SIGNALS = [
+  'review code', 'code review', 'kiểm tra code',
+  'đánh giá', 'nhận xét', 'feedback on', 'góp ý',
+  'proofreading', 'chỉnh sửa văn bản', 'sửa lỗi chính tả',
+  'audit', 'kiểm tra lỗi', 'check this', 'xem lại',
+  'có vấn đề gì không', 'có bug không', 'bảo mật',
+];
+
+// ── Rule 68 — sensitivity tiers ──────────────────────────────────────────────
+// Canonical marker tables live in src/route.rs (yamtam-rt). This JS mirror
+// keeps the fallback classifier and the web UI honest when the binary is
+// missing or stale. Tier decides persistence + which model may see the text.
+
+const SOVEREIGN_MARKERS = [
+  'chỉ mình anh biết', 'chỉ anh biết', 'chỉ riêng anh', 'không ai được biết',
+  'sovereign only', 'for my eyes only', 'local model only', 'chỉ model local',
+  '#sovereign',
+];
+
+const CONFIDENTIAL_MARKERS = [
+  'bí mật', 'tuyệt mật', 'confidential', 'đừng ghi lại', 'đừng lưu',
+  'không lưu lại', 'không ghi lại', 'không được lưu', 'giữ kín',
+  'off the record', 'do not log', "don't log", 'do not save', "don't save",
+  'do not persist', '#mật', '#confidential', '#private',
+];
+
+const CONFIDENTIAL_SMELLS = [
+  'mua công ty', 'bán công ty', 'thương vụ', 'sáp nhập', 'đàm phán',
+  'acquisition', 'merger', 'negotiation position', 'lương của', 'salary of',
+  'chẩn đoán', 'diagnosis', 'bệnh án', 'health record', 'kiện tụng', 'lawsuit',
+  'chưa công bố', 'chưa công khai', 'unannounced',
+];
+
+const SENSITIVITY_POLICY = {
+  public:       { allow_persist: true,  model_scope: 'any' },
+  internal:     { allow_persist: true,  model_scope: 'any' },
+  confidential: { allow_persist: false, model_scope: 'cloud-redacted' },
+  sovereign:    { allow_persist: false, model_scope: 'local-only' },
+};
+
+/** classifySensitivity(text) → { sensitivity, signals } — marker > smell > public > internal */
+function classifySensitivity(text) {
+  const lower = String(text || '').toLowerCase();
+  const hits = set => set.filter(m => lower.includes(m));
+
+  const sov = hits(SOVEREIGN_MARKERS);
+  if (sov.length) return { sensitivity: 'sovereign', signals: sov };
+
+  const conf = hits(CONFIDENTIAL_MARKERS);
+  if (conf.length) return { sensitivity: 'confidential', signals: conf };
+
+  const smell = hits(CONFIDENTIAL_SMELLS);
+  if (smell.length) return { sensitivity: 'confidential', signals: smell };
+
+  if (lower.includes('#public')) return { sensitivity: 'public', signals: ['#public'] };
+  return { sensitivity: 'internal', signals: [] };
+}
+
+function findMatches(task, signals) {
+  const lower = task.toLowerCase();
+  return signals.filter(s => lower.includes(s.toLowerCase()));
+}
+
+/**
+ * createClassifier({ indexPath }) → { classify, matchSkills }
+ *
+ * @param {object} cfg
+ * @param {string} cfg.indexPath  Path to skill-trigger-index.json
+ */
+function createClassifier({ indexPath } = {}) {
+  let SKILL_INDEX = [];
+  if (indexPath) {
+    try { SKILL_INDEX = JSON.parse(fs.readFileSync(indexPath, 'utf8')); } catch (_) {}
+  }
+
+  function matchSkills(task) {
+    if (SKILL_INDEX.length === 0) return [];
+    const lower = task.toLowerCase();
+    const scored = [];
+
+    for (const entry of SKILL_INDEX) {
+      let score = 0;
+      const hits = [];
+      for (const trigger of entry.triggers) {
+        if (lower.includes(trigger)) {
+          score += 1 + Math.floor(trigger.length / 8);
+          hits.push(trigger);
+        } else {
+          const parts = trigger.split(' ');
+          if (parts.length === 2) {
+            const rev = `${parts[1]} ${parts[0]}`;
+            if (lower.includes(rev)) {
+              score += 1;
+              hits.push(trigger);
+            }
+          }
+        }
+      }
+      if (score > 0) scored.push({ name: entry.name, score, hits });
+    }
+
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, 3);
+  }
+
+  function classify(task) {
+    if (typeof task !== 'string') task = String(task || '');
+    const { sensitivity, signals } = classifySensitivity(task);
+    const policy = SENSITIVITY_POLICY[sensitivity];
+    return {
+      ...classifyRoute(task),
+      sensitivity,
+      allow_persist:       policy.allow_persist,
+      model_scope:         policy.model_scope,
+      sensitivity_signals: signals,
+    };
+  }
+
+  function classifyRoute(task) {
+    const extMatches = findMatches(task, EXTERNAL_SIGNALS);
+    if (extMatches.length > 0) {
+      return {
+        route:           'external',
+        gate:            'confirm',
+        confidence:      Math.min(0.6 + extMatches.length * 0.1, 0.95),
+        reason:          'Task involves external side-effects or irreversible actions',
+        matched_signals: extMatches,
+        matched_skills:  [],
+        suggested_agents: ['security-engineer', 'deployment-engineer'],
+      };
+    }
+
+    const skillMatches = matchSkills(task);
+    if (skillMatches.length > 0 && skillMatches[0].score >= 1) {
+      const top = skillMatches[0];
+      const confidence = Math.min(0.55 + top.score * 0.07, 0.95);
+      return {
+        route:           'skill',
+        gate:            'harness',
+        confidence,
+        reason:          `Matched skill: ${top.name} (triggers: ${top.hits.slice(0, 3).join(', ')})`,
+        matched_signals: top.hits,
+        matched_skills:  skillMatches.map(s => s.name),
+        suggested_agents: [top.name],
+      };
+    }
+
+    const learnMatches = findMatches(task, LEARNING_SIGNALS);
+    if (learnMatches.length > 0) {
+      return {
+        route:           'learn',
+        gate:            'auto',
+        confidence:      Math.min(0.65 + learnMatches.length * 0.08, 0.92),
+        reason:          'Learning or explanation request detected',
+        matched_signals: learnMatches,
+        matched_skills:  skillMatches.map(s => s.name),
+        suggested_agents: ['hoc-tap'],
+      };
+    }
+
+    const dailyMatches = findMatches(task, DAILY_SIGNALS);
+    if (dailyMatches.length > 0) {
+      return {
+        route:           'daily',
+        gate:            'auto',
+        confidence:      Math.min(0.65 + dailyMatches.length * 0.08, 0.92),
+        reason:          'Daily work task detected',
+        matched_signals: dailyMatches,
+        matched_skills:  skillMatches.map(s => s.name),
+        suggested_agents: ['daily-assistant'],
+      };
+    }
+
+    const creativeMatches = findMatches(task, CREATIVE_SIGNALS);
+    if (creativeMatches.length > 0) {
+      return {
+        route:           'creative',
+        gate:            'auto',
+        confidence:      Math.min(0.65 + creativeMatches.length * 0.08, 0.92),
+        reason:          'Creative writing or content request detected',
+        matched_signals: creativeMatches,
+        matched_skills:  skillMatches.map(s => s.name),
+        suggested_agents: ['creative-writer', 'documentation-writer'],
+      };
+    }
+
+    const dataMatches = findMatches(task, DATA_SIGNALS);
+    if (dataMatches.length > 0) {
+      return {
+        route:           'data',
+        gate:            'auto',
+        confidence:      Math.min(0.65 + dataMatches.length * 0.08, 0.92),
+        reason:          'Data analysis or SQL task detected',
+        matched_signals: dataMatches,
+        matched_skills:  skillMatches.map(s => s.name),
+        suggested_agents: ['data-analyst', 'database-reviewer'],
+      };
+    }
+
+    const reviewMatches = findMatches(task, REVIEW_SIGNALS);
+    if (reviewMatches.length > 0) {
+      return {
+        route:           'review',
+        gate:            'auto',
+        confidence:      Math.min(0.65 + reviewMatches.length * 0.08, 0.92),
+        reason:          'Review or audit task detected',
+        matched_signals: reviewMatches,
+        matched_skills:  skillMatches.map(s => s.name),
+        suggested_agents: ['code-reviewer', 'react-reviewer'],
+      };
+    }
+
+    const cplxMatches = findMatches(task, COMPLEX_SIGNALS);
+    if (cplxMatches.length > 0) {
+      return {
+        route:           'complex',
+        gate:            'harness',
+        confidence:      Math.min(0.6 + cplxMatches.length * 0.1, 0.95),
+        reason:          'Task requires multi-step code changes or analysis',
+        matched_signals: cplxMatches,
+        matched_skills:  skillMatches.map(s => s.name),
+        suggested_agents: ['backend-developer', 'code-reviewer'],
+      };
+    }
+
+    return {
+      route:           'simple',
+      gate:            'auto',
+      confidence:      0.5,
+      reason:          'No complex or external signals detected',
+      matched_signals: [],
+      matched_skills:  skillMatches.map(s => s.name),
+      suggested_agents: [],
+    };
+  }
+
+  return { classify, matchSkills };
+}
+
+module.exports = { createClassifier, classifySensitivity };

package/src/index.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const path = require('path');
+const { createClassifier, classifySensitivity } = require('./classifier');
+const { createAgents }     = require('./agents');
+const { createSkills }     = require('./skills');
+const { createRouter }     = require('./router');
+
+/**
+ * createCore(config) — wire all YAMTAM subsystems with a single root dir.
+ *
+ * @param {object} config
+ * @param {string} [config.rootDir]        Repo root (default: cwd)
+ * @param {string} [config.skillsDir]      Override core/skills path
+ * @param {string} [config.agentsDir]      Override core/agents path
+ * @param {string} [config.skillIndexPath] Override core/config/skill-trigger-index.json
+ * @param {string} [config.wrapperPath]    Override scripts/yamtam-rt-wrapper.js
+ */
+function createCore(config = {}) {
+  const root = config.rootDir || process.cwd();
+
+  const resolved = {
+    indexPath:   config.skillIndexPath || path.join(root, 'core', 'config', 'skill-trigger-index.json'),
+    agentsDir:   config.agentsDir      || path.join(root, 'core', 'agents'),
+    skillsDir:   config.skillsDir      || path.join(root, 'core', 'skills'),
+    wrapperPath: config.wrapperPath    || path.join(root, 'scripts', 'yamtam-rt-wrapper.js'),
+  };
+
+  const { classify, matchSkills }                    = createClassifier(resolved);
+  const { loadSystemPrompt }                         = createAgents(resolved);
+  const { findBestSkill, loadSkillPrompt, skillCount } = createSkills(resolved);
+  const { route }                                    = createRouter({ classify, wrapperPath: resolved.wrapperPath });
+
+  return { classify, matchSkills, route, loadSystemPrompt, findBestSkill, loadSkillPrompt, skillCount };
+}
+
+module.exports = { createCore, classifySensitivity };

package/src/router.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const path       = require('path');
+const { execFile } = require('child_process');
+
+/**
+ * createRouter({ classify, wrapperPath }) → { route }
+ *
+ * Tries the yamtam-rt native binary first; falls back to JS classifier.
+ */
+function createRouter({ classify, wrapperPath } = {}) {
+  const WRAPPER = wrapperPath || null;
+
+  function spawnRouter(task) {
+    return new Promise((resolve, reject) => {
+      if (!WRAPPER) { reject(new Error('no wrapper')); return; }
+      execFile(
+        'node',
+        [WRAPPER, 'route', 'classify', task],
+        { env: process.env, timeout: 5000 },
+        (err, stdout) => {
+          if (err) { reject(err); return; }
+          let parsed;
+          try { parsed = JSON.parse(stdout); } catch (e) { reject(e); return; }
+          if (!parsed || typeof parsed.route !== 'string') {
+            reject(new Error('unexpected output shape'));
+            return;
+          }
+          resolve(parsed);
+        }
+      );
+    });
+  }
+
+  function route(task) {
+    return new Promise(resolve => {
+      spawnRouter(task)
+        .then(decision => resolve({ ...decision, source: 'yana-router' }))
+        .catch(() => resolve({ ...classify(task), source: 'fallback' }));
+    });
+  }
+
+  return { route };
+}
+
+module.exports = { createRouter };

package/src/skills.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const SKILL_FILE       = 'SKILL.md';
+const MAX_PROMPT_BYTES = 8 * 1024;
+const MIN_TOKEN_LEN    = 3;
+
+/**
+ * createSkills({ skillsDir }) → { findBestSkill, loadSkillPrompt, skillCount }
+ */
+function createSkills({ skillsDir } = {}) {
+  const SKILLS_DIR = skillsDir || '';
+  const index = new Map(); // name → dirPath
+
+  if (SKILLS_DIR) {
+    try {
+      const entries = fs.readdirSync(SKILLS_DIR, { withFileTypes: true });
+      for (const ent of entries) {
+        if (ent.isDirectory()) {
+          index.set(ent.name.toLowerCase(), path.join(SKILLS_DIR, ent.name));
+        }
+      }
+    } catch (_) {}
+  }
+
+  function tokenize(text) {
+    return text
+      .toLowerCase()
+      .replace(/[^a-z0-9 ]/g, ' ')
+      .split(/\s+/)
+      .filter(t => t.length >= MIN_TOKEN_LEN);
+  }
+
+  function findBestSkill(task) {
+    const tokens = tokenize(task);
+    if (tokens.length === 0) return null;
+    let bestName = null, bestScore = 0;
+    for (const name of index.keys()) {
+      let score = 0;
+      for (const tok of tokens) {
+        if (name.includes(tok)) score++;
+      }
+      if (score > bestScore) { bestScore = score; bestName = name; }
+    }
+    return bestScore >= 1 ? bestName : null;
+  }
+
+  function stripFrontmatter(content) {
+    const lines = content.split('\n');
+    if (lines[0].trim() !== '---') return content;
+    const closeIdx = lines.findIndex((l, i) => i > 0 && l.trim() === '---');
+    return closeIdx < 0 ? content : lines.slice(closeIdx + 1).join('\n').trim();
+  }
+
+  function loadSkillPrompt(name) {
+    const dirPath = index.get(name);
+    if (!dirPath) return null;
+    try {
+      const raw  = fs.readFileSync(path.join(dirPath, SKILL_FILE), 'utf8');
+      const body = stripFrontmatter(raw);
+      const buf  = Buffer.from(body, 'utf8');
+      if (buf.length <= MAX_PROMPT_BYTES) return body;
+      return buf.slice(0, MAX_PROMPT_BYTES).toString('utf8') + '\n\n[...skill truncated at 8 KB]';
+    } catch (_) { return null; }
+  }
+
+  return { findBestSkill, loadSkillPrompt, skillCount: () => index.size };
+}
+
+module.exports = { createSkills };