upfynai-code 2.8.2 → 2.8.4

package/dist/agents/gitagent.js

@@ -0,0 +1,67 @@
+/**
+ * Gitagent Agent
+ * Handles: gitagent-detect, gitagent-parse
+ *
+ * Relay-compatible actions for detecting and parsing gitagent directory structures
+ * on the user's local machine.
+ */
+import fs from 'fs';
+import { promises as fsp } from 'fs';
+import path from 'path';
+import { detectGitagent, parseGitagentRepo } from '../gitagent/parser.js';
+
+/** fs-backed helpers injected into the parser */
+async function fsFileExists(filePath) {
+  try {
+    await fsp.access(filePath, fs.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function fsReadFile(filePath) {
+  try {
+    return await fsp.readFile(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+async function fsListDir(dirPath) {
+  try {
+    return await fsp.readdir(dirPath);
+  } catch {
+    return [];
+  }
+}
+
+export default {
+  name: 'gitagent',
+  actions: {
+    /**
+     * Lightweight check for agent.yaml existence.
+     * @param {{ projectPath: string }} params
+     * @returns {{ detected: boolean }}
+     */
+    'gitagent-detect': async (params) => {
+      const projectPath = params.projectPath;
+      if (!projectPath) return { detected: false };
+      const detected = await detectGitagent(projectPath, fsFileExists);
+      return { detected };
+    },
+
+    /**
+     * Full parse — returns the complete GitagentDefinition as JSON.
+     * @param {{ projectPath: string }} params
+     * @returns {{ definition: object|null }}
+     */
+    'gitagent-parse': async (params) => {
+      const projectPath = params.projectPath;
+      if (!projectPath) return { definition: null };
+
+      const definition = await parseGitagentRepo(projectPath, fsReadFile, fsListDir);
+      return { definition };
+    },
+  },
+};

package/dist/agents/index.js

@@ -24,8 +24,9 @@ import filesAgent from './files.js';
 import gitAgent from './git.js';
 import execAgent from './exec.js';
 import detectAgent from './detect.js';
+import gitagentAgent from './gitagent.js';
 
-const agents = [claudeAgent, codexAgent, cursorAgent, shellAgent, filesAgent, gitAgent, execAgent, detectAgent];
+const agents = [claudeAgent, codexAgent, cursorAgent, shellAgent, filesAgent, gitAgent, execAgent, detectAgent, gitagentAgent];
 
 /** Map of action name → handler function */
 const actionMap = new Map();

package/dist/gitagent/index.js

@@ -0,0 +1,9 @@
+/**
+ * Gitagent — Re-exports
+ *
+ * Usage:
+ *   import { detectGitagent, parseGitagentRepo } from 'upfynai-shared/gitagent';
+ *   import { buildSystemPromptAppendix, mapGitagentModel } from 'upfynai-shared/gitagent';
+ */
+export { detectGitagent, parseGitagentRepo } from './parser.js';
+export { buildSystemPromptAppendix, mapGitagentModel, extractAllowedTools } from './prompt-builder.js';

package/dist/gitagent/parser.js

@@ -0,0 +1,202 @@
+/**
+ * Gitagent Parser
+ *
+ * Reads a project directory following the gitagent spec (https://github.com/open-gitagent/gitagent)
+ * and produces a GitagentDefinition object. All file I/O is dependency-injected so the parser
+ * works for both local fs and relay file-read paths.
+ *
+ * @typedef {Object} GitagentDefinition
+ * @property {Object} manifest       - Parsed agent.yaml
+ * @property {string|null} soul      - SOUL.md content
+ * @property {string|null} rules     - RULES.md content
+ * @property {string|null} agents    - AGENTS.md content
+ * @property {Array} skills          - Parsed skill definitions
+ * @property {Array} tools           - Parsed tool schemas
+ * @property {Object|null} knowledge - Knowledge index + always-loaded docs
+ * @property {string|null} memory    - MEMORY.md content
+ */
+
+import yaml from 'js-yaml';
+
+/**
+ * Lightweight check: does agent.yaml exist in the project root?
+ * @param {string} projectPath - Absolute path to the project
+ * @param {(filePath: string) => Promise<boolean>} fileExists - Injected existence check
+ * @returns {Promise<boolean>}
+ */
+export async function detectGitagent(projectPath, fileExists) {
+  try {
+    return await fileExists(join(projectPath, 'agent.yaml'));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Full parse of a gitagent directory into a definition object.
+ * @param {string} projectPath
+ * @param {(filePath: string) => Promise<string|null>} readFile - Returns file content or null
+ * @param {(dirPath: string) => Promise<string[]>} listDir - Returns entry names or []
+ * @returns {Promise<GitagentDefinition|null>}
+ */
+export async function parseGitagentRepo(projectPath, readFile, listDir) {
+  // Read manifest — required
+  const agentYamlContent = await readFile(join(projectPath, 'agent.yaml'));
+  if (!agentYamlContent) return null;
+
+  let manifest;
+  try {
+    manifest = yaml.load(agentYamlContent);
+  } catch {
+    return null;
+  }
+  if (!manifest || typeof manifest !== 'object') return null;
+
+  // Read core markdown files (all optional)
+  const [soul, rules, agents, memory] = await Promise.all([
+    safeRead(readFile, join(projectPath, 'SOUL.md')),
+    safeRead(readFile, join(projectPath, 'RULES.md')),
+    safeRead(readFile, join(projectPath, 'AGENTS.md')),
+    safeRead(readFile, join(projectPath, 'memory', 'MEMORY.md')),
+  ]);
+
+  // Parse skills
+  const skills = await parseSkills(projectPath, manifest.skills, readFile, listDir);
+
+  // Parse tools
+  const tools = await parseTools(projectPath, manifest.tools, readFile, listDir);
+
+  // Parse knowledge
+  const knowledge = await parseKnowledge(projectPath, readFile);
+
+  return { manifest, soul, rules, agents, skills, tools, knowledge, memory };
+}
+
+// ── Internal helpers ────────────────────────────────────────────────
+
+function join(...parts) {
+  // Simple platform-agnostic join (works with / on all platforms in Node)
+  return parts.join('/').replace(/\/+/g, '/');
+}
+
+async function safeRead(readFile, filePath) {
+  try {
+    return await readFile(filePath) || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Parse skills from the skills/ directory.
+ * Each skill is a subfolder containing SKILL.md with optional YAML frontmatter.
+ */
+async function parseSkills(projectPath, declaredSkills, readFile, listDir) {
+  const skillsDir = join(projectPath, 'skills');
+  let entries;
+  try {
+    entries = await listDir(skillsDir);
+  } catch {
+    return [];
+  }
+  if (!entries || entries.length === 0) return [];
+
+  const skills = [];
+  for (const entry of entries) {
+    const skillMd = await safeRead(readFile, join(skillsDir, entry, 'SKILL.md'));
+    if (!skillMd) continue;
+
+    const { frontmatter, body } = parseFrontmatter(skillMd);
+    skills.push({
+      name: entry,
+      ...(frontmatter || {}),
+      description: body || null,
+    });
+  }
+  return skills;
+}
+
+/**
+ * Parse tool definitions from tools/ directory.
+ * Each tool is a YAML file: tools/{name}.yaml
+ */
+async function parseTools(projectPath, declaredTools, readFile, listDir) {
+  const toolsDir = join(projectPath, 'tools');
+  let entries;
+  try {
+    entries = await listDir(toolsDir);
+  } catch {
+    return [];
+  }
+  if (!entries || entries.length === 0) return [];
+
+  const tools = [];
+  for (const entry of entries) {
+    if (!entry.endsWith('.yaml') && !entry.endsWith('.yml')) continue;
+    const content = await safeRead(readFile, join(toolsDir, entry));
+    if (!content) continue;
+    try {
+      const schema = yaml.load(content);
+      if (schema && typeof schema === 'object') {
+        tools.push({ name: entry.replace(/\.ya?ml$/, ''), ...schema });
+      }
+    } catch {
+      // skip invalid tool yaml
+    }
+  }
+  return tools;
+}
+
+/**
+ * Parse knowledge index and load always_load documents.
+ */
+async function parseKnowledge(projectPath, readFile) {
+  const indexContent = await safeRead(readFile, join(projectPath, 'knowledge', 'index.yaml'));
+  if (!indexContent) return null;
+
+  let index;
+  try {
+    index = yaml.load(indexContent);
+  } catch {
+    return null;
+  }
+  if (!index || typeof index !== 'object') return null;
+
+  // Load documents flagged as always_load
+  const alwaysLoadDocs = [];
+  const documents = index.documents || index.files || [];
+  for (const doc of documents) {
+    if (!doc.always_load) continue;
+    const docPath = doc.path || doc.file;
+    if (!docPath) continue;
+    const content = await safeRead(readFile, join(projectPath, 'knowledge', docPath));
+    if (content) {
+      alwaysLoadDocs.push({ path: docPath, title: doc.title || docPath, content });
+    }
+  }
+
+  return { index, alwaysLoadDocs };
+}
+
+/**
+ * Parse YAML frontmatter from a markdown file.
+ * Frontmatter is delimited by --- at the start of the file.
+ * @returns {{ frontmatter: object|null, body: string }}
+ */
+function parseFrontmatter(content) {
+  if (!content.startsWith('---')) {
+    return { frontmatter: null, body: content.trim() };
+  }
+  const endIdx = content.indexOf('---', 3);
+  if (endIdx === -1) {
+    return { frontmatter: null, body: content.trim() };
+  }
+  const fmRaw = content.slice(3, endIdx).trim();
+  const body = content.slice(endIdx + 3).trim();
+  try {
+    const frontmatter = yaml.load(fmRaw);
+    return { frontmatter: frontmatter && typeof frontmatter === 'object' ? frontmatter : null, body };
+  } catch {
+    return { frontmatter: null, body: content.trim() };
+  }
+}

package/dist/gitagent/prompt-builder.js

@@ -0,0 +1,153 @@
+/**
+ * Gitagent Prompt Builder
+ *
+ * Converts a GitagentDefinition (from parser.js) into strings/configs
+ * that can be injected into Claude SDK options.
+ */
+
+/**
+ * Model name mapping from gitagent spec model IDs to UpfynAI model IDs.
+ * Gitagent uses full Anthropic model IDs; we map to short names.
+ */
+const MODEL_MAP = {
+  'claude-opus-4-6':            'opus',
+  'claude-opus-4-20250514':     'opus',
+  'claude-sonnet-4-6':          'sonnet',
+  'claude-sonnet-4-5-20250929': 'sonnet',
+  'claude-haiku-4-5-20251001':  'haiku',
+  // Generic short names pass through
+  'opus':   'opus',
+  'sonnet': 'sonnet',
+  'haiku':  'haiku',
+};
+
+/**
+ * Build a system prompt appendix from a parsed gitagent definition.
+ * Wrapped in <gitagent-context> tags so Claude can distinguish it.
+ *
+ * @param {import('./parser.js').GitagentDefinition} def
+ * @returns {string}
+ */
+export function buildSystemPromptAppendix(def) {
+  const sections = [];
+
+  // Identity header from manifest
+  const m = def.manifest;
+  sections.push(`# Gitagent: ${m.name} v${m.version || '0.0.0'}`);
+  if (m.description) sections.push(m.description);
+
+  // SOUL — agent identity & personality
+  if (def.soul) {
+    sections.push(`## Identity (SOUL)\n${def.soul}`);
+  }
+
+  // RULES — hard constraints
+  if (def.rules) {
+    sections.push(`## Rules\n${def.rules}`);
+  }
+
+  // AGENTS — framework-agnostic instructions
+  if (def.agents) {
+    sections.push(`## Agent Instructions\n${def.agents}`);
+  }
+
+  // Skills
+  if (def.skills && def.skills.length > 0) {
+    const skillLines = def.skills.map(s => {
+      const header = `### ${s.name}`;
+      const meta = [];
+      if (s.version) meta.push(`v${s.version}`);
+      if (s.tools && s.tools.length) meta.push(`tools: ${s.tools.join(', ')}`);
+      const metaLine = meta.length ? ` (${meta.join(' | ')})` : '';
+      return `${header}${metaLine}\n${s.description || ''}`;
+    });
+    sections.push(`## Skills\n${skillLines.join('\n\n')}`);
+  }
+
+  // Tools
+  if (def.tools && def.tools.length > 0) {
+    const toolLines = def.tools.map(t => {
+      const parts = [`### ${t.name}`];
+      if (t.description) parts.push(t.description);
+      if (t.input_schema || t.parameters) {
+        const schema = t.input_schema || t.parameters;
+        if (schema.properties) {
+          const props = Object.entries(schema.properties)
+            .map(([k, v]) => `- \`${k}\`: ${v.type || 'any'}${v.description ? ' — ' + v.description : ''}`)
+            .join('\n');
+          parts.push(`Parameters:\n${props}`);
+        }
+      }
+      return parts.join('\n');
+    });
+    sections.push(`## Tools\n${toolLines.join('\n\n')}`);
+  }
+
+  // Knowledge (always-loaded docs)
+  if (def.knowledge && def.knowledge.alwaysLoadDocs && def.knowledge.alwaysLoadDocs.length > 0) {
+    const knowledgeLines = def.knowledge.alwaysLoadDocs.map(d =>
+      `### ${d.title}\n${d.content}`
+    );
+    sections.push(`## Knowledge\n${knowledgeLines.join('\n\n')}`);
+  }
+
+  // Memory
+  if (def.memory) {
+    sections.push(`## Memory\n${def.memory}`);
+  }
+
+  // Runtime constraints
+  if (m.runtime) {
+    const rc = [];
+    if (m.runtime.max_turns) rc.push(`Max turns: ${m.runtime.max_turns}`);
+    if (m.runtime.timeout) rc.push(`Timeout: ${m.runtime.timeout}s`);
+    if (rc.length) sections.push(`## Runtime\n${rc.join('\n')}`);
+  }
+
+  return sections.join('\n\n');
+}
+
+/**
+ * Map a gitagent model config to an UpfynAI model ID.
+ * @param {Object|string} modelConfig - model field from agent.yaml
+ * @returns {string|null} UpfynAI model ID or null if no mapping
+ */
+export function mapGitagentModel(modelConfig) {
+  if (!modelConfig) return null;
+
+  // String shorthand: model: "claude-sonnet-4-5-20250929"
+  if (typeof modelConfig === 'string') {
+    return MODEL_MAP[modelConfig] || null;
+  }
+
+  // Object form: model: { preferred: "...", fallback: [...] }
+  if (modelConfig.preferred) {
+    return MODEL_MAP[modelConfig.preferred] || null;
+  }
+
+  return null;
+}
+
+/**
+ * Extract a deduplicated list of allowed tool names from all parsed skills.
+ * @param {Array} skills - Parsed skill definitions
+ * @returns {string[]}
+ */
+export function extractAllowedTools(skills) {
+  if (!skills || skills.length === 0) return [];
+
+  const toolSet = new Set();
+  for (const skill of skills) {
+    if (skill.tools && Array.isArray(skill.tools)) {
+      for (const t of skill.tools) {
+        toolSet.add(t);
+      }
+    }
+    if (skill.allowed_tools && Array.isArray(skill.allowed_tools)) {
+      for (const t of skill.allowed_tools) {
+        toolSet.add(t);
+      }
+    }
+  }
+  return Array.from(toolSet);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "upfynai-code",
-  "version": "2.8.2",
+  "version": "2.8.4",
   "description": "Unified AI coding interface — access AI chat, terminal, file explorer, git, and visual canvas from any browser. Connect your local machine and code from anywhere.",
   "type": "module",
   "bin": {
@@ -62,6 +62,7 @@
     "commander": "^12.1.0",
     "express": "^4.21.0",
     "http-proxy-middleware": "^3.0.0",
+    "js-yaml": "^4.1.0",
     "open": "^10.1.0",
     "prompts": "^2.4.2",
     "ws": "^8.18.0"

package/scripts/prepublish.js

@@ -24,6 +24,7 @@ const files = [
   'index.js', 'utils.js',
   'claude.js', 'codex.js', 'cursor.js',
   'shell.js', 'files.js', 'git.js', 'exec.js', 'detect.js',
+  'gitagent.js',
 ];
 
 let copied = 0;
@@ -38,4 +39,20 @@ for (const file of files) {
   }
 }
 
-console.log(`  [prepublish] Copied ${copied} agent files to dist/agents/`);
+// Copy gitagent module (parser + prompt-builder) — needed by gitagent agent
+const sharedGitagent = join(cliRoot, '..', 'shared', 'gitagent');
+const distGitagent = join(cliRoot, 'dist', 'gitagent');
+if (existsSync(distGitagent)) rmSync(distGitagent, { recursive: true });
+mkdirSync(distGitagent, { recursive: true });
+
+const gitagentFiles = ['index.js', 'parser.js', 'prompt-builder.js'];
+for (const file of gitagentFiles) {
+  const src = join(sharedGitagent, file);
+  const dest = join(distGitagent, file);
+  if (existsSync(src)) {
+    cpSync(src, dest);
+    copied++;
+  }
+}
+
+console.log(`  [prepublish] Copied ${copied} files to dist/`);