tiger-agent 0.2.5 → 0.3.2

package/src/swarm/configStore.js

@@ -0,0 +1,360 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT_DIR = path.resolve(process.env.TIGER_HOME || process.cwd());
+const SWARM_DIR = path.join(ROOT_DIR, 'swarm');
+const ARCHITECTURE_DIR = path.join(SWARM_DIR, 'architecture');
+const TASK_STYLE_DIR = path.join(ROOT_DIR, 'tasks', 'styles');
+const DEFAULT_ARCHITECTURE_FILE = 'tiger_parallel_design.yaml';
+const DEFAULT_TASK_STYLE_FILE = 'default.yaml';
+
+const DEFAULT_ARCHITECTURE_YAML = `version: 1
+name: tiger_parallel_design
+main_orchestrator: tiger
+start_stage: design_parallel
+agents:
+  - id: designer_a
+    runtime_agent: designer
+    role: designer
+  - id: designer_b
+    runtime_agent: designer
+    role: designer
+  - id: designer_c
+    runtime_agent: designer
+    role: designer
+  - id: reviewer
+    runtime_agent: senior_eng
+    role: reviewer
+  - id: spec_writer
+    runtime_agent: spec_writer
+    role: spec_writer
+stages:
+  - id: design_parallel
+    type: parallel
+    roles:
+      - designer_a
+      - designer_b
+      - designer_c
+    store_as: design_candidates
+    next: review_best
+  - id: review_best
+    type: judge
+    role: reviewer
+    candidates_from: design_candidates
+    selected_role_key: selected_role
+    feedback_key: reviewer_feedback
+    pass_next: final_spec
+    fail_next: revise_selected
+  - id: revise_selected
+    type: revise
+    role_from_context: selected_role
+    feedback_from_context: reviewer_feedback
+    candidates_from: design_candidates
+    next: review_best
+  - id: final_spec
+    type: final
+    role: spec_writer
+    source_from_context: design_candidates
+    next: tiger_done
+judgment_matrix:
+  criteria:
+    - name: objective_fit
+      weight: 0.35
+      description: How well the design satisfies the objective.
+    - name: feasibility
+      weight: 0.25
+      description: Delivery realism and technical viability.
+    - name: clarity
+      weight: 0.2
+      description: Readability and implementation clarity.
+    - name: risk
+      weight: 0.2
+      description: Risk exposure and mitigation quality.
+  pass_rule: reviewer_approval
+`;
+
+const DEFAULT_TASK_STYLE_YAML = `version: 1
+name: default
+architecture: tiger_parallel_design.yaml
+flow: architecture
+objective_prefix: "Objective:"
+`;
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function safeName(name) {
+  const text = String(name || '').trim();
+  if (!/^[a-zA-Z0-9._-]+\.ya?ml$/.test(text)) {
+    throw new Error('File name must be a simple .yaml/.yml file name');
+  }
+  return text;
+}
+
+function stripComment(line) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith('#')) return '';
+  return line;
+}
+
+function parseScalar(text) {
+  const value = String(text || '').trim();
+  if (value === '') return '';
+  if (/^".*"$/.test(value) || /^'.*'$/.test(value)) {
+    return value.slice(1, -1);
+  }
+  if (/^\[(.*)\]$/.test(value)) {
+    const inner = value.slice(1, -1).trim();
+    if (!inner) return [];
+    return inner.split(',').map((x) => parseScalar(x.trim()));
+  }
+  if (/^(true|false)$/i.test(value)) return /^true$/i.test(value);
+  if (/^null$/i.test(value)) return null;
+  if (/^-?\d+(\.\d+)?$/.test(value)) return Number(value);
+  return value;
+}
+
+function splitKeyValue(content) {
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < content.length; i += 1) {
+    const ch = content[i];
+    if (ch === "'" && !inDouble) inSingle = !inSingle;
+    if (ch === '"' && !inSingle) inDouble = !inDouble;
+    if (ch === ':' && !inSingle && !inDouble) {
+      return {
+        key: content.slice(0, i).trim(),
+        rest: content.slice(i + 1).trim()
+      };
+    }
+  }
+  return null;
+}
+
+function parseYaml(text, label = 'yaml') {
+  const lines = String(text || '').replace(/\t/g, '  ').split(/\r?\n/);
+  const tokens = [];
+  for (const raw of lines) {
+    const line = stripComment(raw);
+    if (!line.trim()) continue;
+    const indent = line.match(/^\s*/)[0].length;
+    tokens.push({ indent, content: line.trim() });
+  }
+
+  let idx = 0;
+
+  function parseNode(indent) {
+    if (idx >= tokens.length) return {};
+    const token = tokens[idx];
+    if (token.indent < indent) return {};
+    if (token.content.startsWith('- ') && token.indent === indent) return parseSeq(indent);
+    return parseMap(indent);
+  }
+
+  function parseMap(indent) {
+    const out = {};
+    while (idx < tokens.length) {
+      const token = tokens[idx];
+      if (token.indent < indent) break;
+      if (token.indent > indent) {
+        throw new Error(`Invalid indentation near "${token.content}" in ${label}`);
+      }
+      if (token.content.startsWith('- ')) break;
+      const kv = splitKeyValue(token.content);
+      if (!kv || !kv.key) throw new Error(`Invalid mapping line "${token.content}" in ${label}`);
+      idx += 1;
+      if (kv.rest === '') {
+        if (idx < tokens.length && tokens[idx].indent > indent) {
+          out[kv.key] = parseNode(tokens[idx].indent);
+        } else {
+          out[kv.key] = null;
+        }
+      } else {
+        out[kv.key] = parseScalar(kv.rest);
+      }
+    }
+    return out;
+  }
+
+  function parseSeq(indent) {
+    const arr = [];
+    while (idx < tokens.length) {
+      const token = tokens[idx];
+      if (token.indent < indent) break;
+      if (token.indent !== indent || !token.content.startsWith('- ')) break;
+      const rest = token.content.slice(2).trim();
+      idx += 1;
+
+      if (!rest) {
+        if (idx < tokens.length && tokens[idx].indent > indent) {
+          arr.push(parseNode(tokens[idx].indent));
+        } else {
+          arr.push(null);
+        }
+        continue;
+      }
+
+      const kv = splitKeyValue(rest);
+      if (kv && kv.key) {
+        const item = {};
+        if (kv.rest === '') {
+          if (idx < tokens.length && tokens[idx].indent > indent) {
+            item[kv.key] = parseNode(tokens[idx].indent);
+          } else {
+            item[kv.key] = null;
+          }
+        } else {
+          item[kv.key] = parseScalar(kv.rest);
+        }
+        if (idx < tokens.length && tokens[idx].indent > indent) {
+          const extra = parseNode(tokens[idx].indent);
+          if (extra && typeof extra === 'object' && !Array.isArray(extra)) {
+            Object.assign(item, extra);
+          }
+        }
+        arr.push(item);
+      } else {
+        arr.push(parseScalar(rest));
+      }
+    }
+    return arr;
+  }
+
+  if (!tokens.length) return {};
+  return parseNode(tokens[0].indent);
+}
+
+function validateArchitectureObject(obj) {
+  const data = obj && typeof obj === 'object' ? obj : {};
+  const stages = Array.isArray(data.stages) ? data.stages : [];
+  const agents = Array.isArray(data.agents) ? data.agents : [];
+  if (!data.main_orchestrator) throw new Error('architecture.main_orchestrator is required');
+  if (!stages.length) throw new Error('architecture.stages must contain at least one stage');
+  if (!agents.length) throw new Error('architecture.agents must contain at least one agent');
+  for (const stage of stages) {
+    if (!stage || typeof stage !== 'object') throw new Error('Each stage must be an object');
+    if (!stage.id || !stage.type) throw new Error('Each stage requires id and type');
+    const type = String(stage.type).toLowerCase();
+    if (type === 'judge' && (!stage.pass_next || !stage.fail_next)) {
+      throw new Error(`judge stage "${stage.id}" requires pass_next and fail_next`);
+    }
+  }
+}
+
+function validateTaskStyleObject(obj) {
+  const data = obj && typeof obj === 'object' ? obj : {};
+  if (!data.architecture) throw new Error('task_style.architecture is required');
+}
+
+function ensureSwarmConfigLayout() {
+  ensureDir(ARCHITECTURE_DIR);
+  ensureDir(TASK_STYLE_DIR);
+  const architecturePath = path.join(ARCHITECTURE_DIR, DEFAULT_ARCHITECTURE_FILE);
+  if (!fs.existsSync(architecturePath)) {
+    fs.writeFileSync(architecturePath, DEFAULT_ARCHITECTURE_YAML, 'utf8');
+  }
+  const taskStylePath = path.join(TASK_STYLE_DIR, DEFAULT_TASK_STYLE_FILE);
+  if (!fs.existsSync(taskStylePath)) {
+    fs.writeFileSync(taskStylePath, DEFAULT_TASK_STYLE_YAML, 'utf8');
+  }
+}
+
+function listArchitectureFiles() {
+  ensureSwarmConfigLayout();
+  return fs
+    .readdirSync(ARCHITECTURE_DIR)
+    .filter((name) => /\.ya?ml$/i.test(name))
+    .sort();
+}
+
+function listTaskStyleFiles() {
+  ensureSwarmConfigLayout();
+  return fs
+    .readdirSync(TASK_STYLE_DIR)
+    .filter((name) => /\.ya?ml$/i.test(name))
+    .sort();
+}
+
+function readArchitectureText(name = DEFAULT_ARCHITECTURE_FILE) {
+  ensureSwarmConfigLayout();
+  const fileName = safeName(name);
+  return fs.readFileSync(path.join(ARCHITECTURE_DIR, fileName), 'utf8');
+}
+
+function writeArchitectureText(name, text) {
+  ensureSwarmConfigLayout();
+  const fileName = safeName(name);
+  const parsed = parseYaml(text, `architecture (${fileName})`);
+  validateArchitectureObject(parsed);
+  fs.writeFileSync(path.join(ARCHITECTURE_DIR, fileName), String(text || ''), 'utf8');
+  return { fileName, parsed };
+}
+
+function readTaskStyleText(name = DEFAULT_TASK_STYLE_FILE) {
+  ensureSwarmConfigLayout();
+  const fileName = safeName(name);
+  return fs.readFileSync(path.join(TASK_STYLE_DIR, fileName), 'utf8');
+}
+
+function writeTaskStyleText(name, text) {
+  ensureSwarmConfigLayout();
+  const fileName = safeName(name);
+  const parsed = parseYaml(text, `task style (${fileName})`);
+  validateTaskStyleObject(parsed);
+  fs.writeFileSync(path.join(TASK_STYLE_DIR, fileName), String(text || ''), 'utf8');
+  return { fileName, parsed };
+}
+
+function loadTaskStyle(name = DEFAULT_TASK_STYLE_FILE) {
+  const text = readTaskStyleText(name);
+  const parsed = parseYaml(text, `task style (${name})`);
+  validateTaskStyleObject(parsed);
+  return parsed;
+}
+
+function loadArchitecture(name = DEFAULT_ARCHITECTURE_FILE) {
+  const text = readArchitectureText(name);
+  const parsed = parseYaml(text, `architecture (${name})`);
+  validateArchitectureObject(parsed);
+  return parsed;
+}
+
+function updateDefaultStyleArchitecture(architectureFile) {
+  const fileName = safeName(architectureFile);
+  ensureSwarmConfigLayout();
+  const stylePath = path.join(TASK_STYLE_DIR, DEFAULT_TASK_STYLE_FILE);
+  const text = fs.readFileSync(stylePath, 'utf8');
+  const lines = text.split(/\r?\n/);
+  let replaced = false;
+  const out = lines.map((line) => {
+    if (/^\s*architecture\s*:/.test(line)) {
+      replaced = true;
+      return `architecture: ${fileName}`;
+    }
+    return line;
+  });
+  if (!replaced) out.push(`architecture: ${fileName}`);
+  const next = out.join('\n').replace(/\n*$/, '\n');
+  writeTaskStyleText(DEFAULT_TASK_STYLE_FILE, next);
+  return loadTaskStyle(DEFAULT_TASK_STYLE_FILE);
+}
+
+module.exports = {
+  ARCHITECTURE_DIR,
+  TASK_STYLE_DIR,
+  DEFAULT_ARCHITECTURE_FILE,
+  DEFAULT_TASK_STYLE_FILE,
+  ensureSwarmConfigLayout,
+  listArchitectureFiles,
+  listTaskStyleFiles,
+  readArchitectureText,
+  writeArchitectureText,
+  readTaskStyleText,
+  writeTaskStyleText,
+  loadTaskStyle,
+  loadArchitecture,
+  updateDefaultStyleArchitecture
+};

package/src/swarm/index.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const { ensureSwarmLayout } = require('./taskBus');
+const {
+  runTigerFlow,
+  continueTask,
+  runWorkerTurn,
+  cancelTask,
+  deleteTask,
+  askAgent,
+  getAgentsStatus,
+  getStatusSummary
+} = require('./agentRuntime');
+
+module.exports = {
+  ensureSwarmLayout,
+  runTigerFlow,
+  continueTask,
+  runWorkerTurn,
+  cancelTask,
+  deleteTask,
+  askAgent,
+  getAgentsStatus,
+  getStatusSummary
+};

package/src/swarm/taskBus.js

@@ -0,0 +1,246 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT_DIR = path.resolve(process.env.TIGER_HOME || process.cwd());
+const TASKS_DIR = path.join(ROOT_DIR, 'tasks');
+const AGENTS_DIR = path.join(ROOT_DIR, 'agents');
+
+const TASK_BUCKETS = ['pending', 'in_progress', 'done', 'failed'];
+const DEFAULT_AGENT_DIRS = [
+  'tiger',
+  'designer',
+  'designer_a',
+  'designer_b',
+  'designer_c',
+  'senior_eng',
+  'spec_writer',
+  'scout',
+  'coder',
+  'critic'
+];
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function writeJsonAtomic(filePath, value) {
+  const dir = path.dirname(filePath);
+  ensureDir(dir);
+  const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+  fs.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+  fs.renameSync(tmp, filePath);
+}
+
+function safeReadJson(filePath) {
+  const raw = fs.readFileSync(filePath, 'utf8');
+  return JSON.parse(raw);
+}
+
+function defaultAgentFileContent(agentName, fileName) {
+  if (fileName === 'soul.md') {
+    return `# ${agentName}\n\n## Identity\n${agentName} worker for Tiger swarm.\n`;
+  }
+  if (fileName === 'ownskill.md') {
+    return `# ownskill\n\n- Role: ${agentName}\n`;
+  }
+  if (fileName === 'memory.md') {
+    return `# memory\n\n`;
+  }
+  if (fileName === 'human.md' && agentName === 'tiger') {
+    return '# human\n\n';
+  }
+  if (fileName === 'experience.json') {
+    return JSON.stringify(
+      {
+        total_tasks: 0,
+        success_rate: 0,
+        lessons: [],
+        collaboration: {}
+      },
+      null,
+      2
+    ) + '\n';
+  }
+  return '';
+}
+
+function ensureAgentFolder(agentName) {
+  const dir = path.join(AGENTS_DIR, agentName);
+  ensureDir(dir);
+  const baseFiles = ['soul.md', 'ownskill.md', 'experience.json', 'memory.md'];
+  if (agentName === 'tiger') baseFiles.push('human.md');
+  for (const fileName of baseFiles) {
+    const full = path.join(dir, fileName);
+    if (!fs.existsSync(full)) {
+      fs.writeFileSync(full, defaultAgentFileContent(agentName, fileName), 'utf8');
+    }
+  }
+}
+
+function ensureSwarmLayout() {
+  ensureDir(TASKS_DIR);
+  ensureDir(AGENTS_DIR);
+  for (const bucket of TASK_BUCKETS) ensureDir(path.join(TASKS_DIR, bucket));
+  for (const agentName of DEFAULT_AGENT_DIRS) ensureAgentFolder(agentName);
+}
+
+function taskFilePath(bucket, taskId) {
+  return path.join(TASKS_DIR, bucket, `${taskId}.json`);
+}
+
+function makeTaskId() {
+  const ts = Date.now().toString(36);
+  const rand = Math.random().toString(36).slice(2, 8);
+  return `task_${ts}_${rand}`;
+}
+
+function formatThreadMsg(by, msg, at = nowIso()) {
+  return { by, at, msg: String(msg || '').trim() };
+}
+
+function createTask({ from = 'tiger', goal, nextAgent = 'designer', flow = 'design', metadata = {} }) {
+  ensureSwarmLayout();
+  const task = {
+    task_id: makeTaskId(),
+    created_at: nowIso(),
+    status: 'pending',
+    from,
+    goal: String(goal || '').trim(),
+    flow,
+    next_agent: nextAgent,
+    thread: [],
+    result: null,
+    metadata
+  };
+  task.thread.push(formatThreadMsg(from, `task created: ${task.goal}`));
+  writeJsonAtomic(taskFilePath('pending', task.task_id), task);
+  return task;
+}
+
+function listTaskFiles(bucket) {
+  ensureSwarmLayout();
+  const dir = path.join(TASKS_DIR, bucket);
+  return fs
+    .readdirSync(dir)
+    .filter((name) => name.endsWith('.json'))
+    .sort()
+    .map((name) => path.join(dir, name));
+}
+
+function readTaskAt(filePath) {
+  const task = safeReadJson(filePath);
+  return { task, filePath };
+}
+
+function listTasks(bucket) {
+  return listTaskFiles(bucket).map((filePath) => readTaskAt(filePath).task);
+}
+
+function findTask(taskId) {
+  for (const bucket of TASK_BUCKETS) {
+    const filePath = taskFilePath(bucket, taskId);
+    if (fs.existsSync(filePath)) {
+      const task = safeReadJson(filePath);
+      return { bucket, filePath, task };
+    }
+  }
+  return null;
+}
+
+function saveTaskInPlace(filePath, task) {
+  writeJsonAtomic(filePath, task);
+}
+
+function moveTaskFile(filePath, targetBucket, task) {
+  const nextPath = taskFilePath(targetBucket, task.task_id);
+  writeJsonAtomic(nextPath, task);
+  if (path.resolve(nextPath) !== path.resolve(filePath) && fs.existsSync(filePath)) {
+    fs.unlinkSync(filePath);
+  }
+  return nextPath;
+}
+
+function appendThread(task, by, msg) {
+  if (!Array.isArray(task.thread)) task.thread = [];
+  const text = String(msg || '').trim();
+  if (!text) return task;
+  task.thread.push(formatThreadMsg(by, text));
+  return task;
+}
+
+function claimPendingTask(agentName) {
+  const candidates = listTaskFiles('pending');
+  for (const filePath of candidates) {
+    const task = safeReadJson(filePath);
+    if (task.next_agent !== agentName) continue;
+    task.status = 'in_progress';
+    const nextPath = moveTaskFile(filePath, 'in_progress', task);
+    return { task, filePath: nextPath, bucket: 'in_progress' };
+  }
+  return null;
+}
+
+function releaseTask(task, filePath, bucket) {
+  const targetBucket = bucket || task.status || 'pending';
+  const nextPath = moveTaskFile(filePath, targetBucket, task);
+  return { task, filePath: nextPath, bucket: targetBucket };
+}
+
+function cancelTask(taskId, by = 'tiger') {
+  const found = findTask(taskId);
+  if (!found) return { ok: false, error: 'Task not found' };
+  const { filePath, task } = found;
+  task.status = 'failed';
+  appendThread(task, by, 'task cancelled');
+  moveTaskFile(filePath, 'failed', task);
+  return { ok: true, task };
+}
+
+function deleteTask(taskId) {
+  const found = findTask(taskId);
+  if (!found) return { ok: false, error: 'Task not found' };
+  const { filePath, task, bucket } = found;
+  if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+  return { ok: true, task, bucket };
+}
+
+function listInProgressTasks() {
+  return listTasks('in_progress');
+}
+
+function listAgentFolders() {
+  ensureSwarmLayout();
+  return fs
+    .readdirSync(AGENTS_DIR, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name)
+    .sort();
+}
+
+module.exports = {
+  ROOT_DIR,
+  TASKS_DIR,
+  AGENTS_DIR,
+  TASK_BUCKETS,
+  ensureSwarmLayout,
+  ensureAgentFolder,
+  createTask,
+  listTasks,
+  listInProgressTasks,
+  findTask,
+  saveTaskInPlace,
+  moveTaskFile,
+  appendThread,
+  claimPendingTask,
+  releaseTask,
+  cancelTask,
+  deleteTask,
+  listAgentFolders,
+  nowIso
+};