keystone-cli 0.1.1 → 0.3.0

package/src/expression/evaluator.ts

@@ -78,10 +78,46 @@ export class ExpressionEvaluator {
       // Extract the expression content between ${{ and }}
       const expr = match.replace(/^\$\{\{\s*|\s*\}\}$/g, '');
       const result = ExpressionEvaluator.evaluateExpression(expr, context);
+
+      if (result === null || result === undefined) {
+        return '';
+      }
+
+      if (typeof result === 'object' && result !== null) {
+        // Special handling for shell command results to avoid [object Object] or JSON in commands
+        if (
+          'stdout' in result &&
+          'exitCode' in result &&
+          typeof (result as Record<string, unknown>).stdout === 'string'
+        ) {
+          return (result as Record<string, unknown>).stdout.trim();
+        }
+        return JSON.stringify(result, null, 2);
+      }
+
       return String(result);
     });
   }
 
+  /**
+   * Evaluate a string and ensure the result is a string.
+   * Objects and arrays are stringified to JSON.
+   * null and undefined return an empty string.
+   */
+  static evaluateString(template: string, context: ExpressionContext): string {
+    const result = ExpressionEvaluator.evaluate(template, context);
+
+    if (result === null || result === undefined) {
+      return '';
+    }
+
+    if (typeof result === 'string') {
+      return result;
+    }
+
+    return JSON.stringify(result, null, 2);
+  }
+
   /**
    * Evaluate a single expression (without the ${{ }} wrapper)
    * This is public to support transform expressions in shell steps

package/src/parser/agent-parser.test.ts

@@ -63,6 +63,16 @@ tools:
       expect(agent.tools[0].execution.id).toBe('tool-tool-without-id');
     });
 
+    it('should parse single-line frontmatter', () => {
+      const agentContent = '---name: single-line---\nPrompt';
+      const filePath = join(tempDir, 'single-line.md');
+      writeFileSync(filePath, agentContent);
+
+      const agent = parseAgent(filePath);
+      expect(agent.name).toBe('single-line');
+      expect(agent.systemPrompt).toBe('Prompt');
+    });
+
     it('should throw error for missing frontmatter', () => {
       const agentContent = 'Just some content without frontmatter';
       const filePath = join(tempDir, 'invalid-format.md');

package/src/parser/agent-parser.ts

@@ -6,7 +6,8 @@ import { type Agent, AgentSchema } from './schema';
 
 export function parseAgent(filePath: string): Agent {
   const content = readFileSync(filePath, 'utf8');
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n([\s\S]*))?$/);
+  // Flexible regex to handle both standard and single-line frontmatter
+  const match = content.match(/^---[\r\n]*([\s\S]*?)[\r\n]*---(?:\r?\n?([\s\S]*))?$/);
 
   if (!match) {
     throw new Error(`Invalid agent format in ${filePath}. Missing frontmatter.`);
@@ -43,11 +44,18 @@ export function parseAgent(filePath: string): Agent {
   return result.data;
 }
 
-export function resolveAgentPath(agentName: string): string {
-  const possiblePaths = [
+export function resolveAgentPath(agentName: string, baseDir?: string): string {
+  const possiblePaths: string[] = [];
+
+  if (baseDir) {
+    possiblePaths.push(join(baseDir, 'agents', `${agentName}.md`));
+    possiblePaths.push(join(baseDir, '..', 'agents', `${agentName}.md`));
+  }
+
+  possiblePaths.push(
     join(process.cwd(), '.keystone', 'workflows', 'agents', `${agentName}.md`),
-    join(homedir(), '.keystone', 'workflows', 'agents', `${agentName}.md`),
-  ];
+    join(homedir(), '.keystone', 'workflows', 'agents', `${agentName}.md`)
+  );
 
   for (const path of possiblePaths) {
     if (existsSync(path)) {

package/src/parser/config-schema.ts

@@ -42,11 +42,30 @@ export const ConfigSchema = z.object({
   workflows_directory: z.string().default('workflows'),
   mcp_servers: z
     .record(
-      z.object({
-        command: z.string(),
-        args: z.array(z.string()).optional(),
-        env: z.record(z.string()).optional(),
-      })
+      z.discriminatedUnion('type', [
+        z.object({
+          type: z.literal('local').default('local'),
+          command: z.string(),
+          args: z.array(z.string()).optional(),
+          env: z.record(z.string()).optional(),
+          url: z.string().url().optional(),
+          oauth: z
+            .object({
+              scope: z.string().optional(),
+            })
+            .optional(),
+        }),
+        z.object({
+          type: z.literal('remote'),
+          url: z.string().url(),
+          headers: z.record(z.string()).optional(),
+          oauth: z
+            .object({
+              scope: z.string().optional(),
+            })
+            .optional(),
+        }),
+      ])
     )
     .default({}),
 });

package/src/parser/schema.ts

@@ -3,7 +3,7 @@ import { z } from 'zod';
 // ===== Input/Output Schema =====
 
 const InputSchema = z.object({
-  type: z.string(),
+  type: z.enum(['string', 'number', 'boolean', 'array', 'object']),
   default: z.any().optional(),
   description: z.string().optional(),
 });

package/src/parser/workflow-parser.ts

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import * as yaml from 'js-yaml';
 import { z } from 'zod';
 import { ExpressionEvaluator } from '../expression/evaluator.ts';
@@ -15,6 +15,7 @@ export class WorkflowParser {
       const content = readFileSync(path, 'utf-8');
       const raw = yaml.load(content);
       const workflow = WorkflowSchema.parse(raw);
+      const workflowDir = dirname(path);
 
       // Resolve implicit dependencies from expressions
       WorkflowParser.resolveImplicitDependencies(workflow);
@@ -23,7 +24,7 @@ export class WorkflowParser {
       WorkflowParser.validateDAG(workflow);
 
       // Validate agents exist
-      WorkflowParser.validateAgents(workflow);
+      WorkflowParser.validateAgents(workflow, workflowDir);
 
       // Validate finally block
       WorkflowParser.validateFinally(workflow);
@@ -121,12 +122,12 @@ export class WorkflowParser {
   /**
    * Validate that all agents referenced in LLM steps exist
    */
-  private static validateAgents(workflow: Workflow): void {
+  private static validateAgents(workflow: Workflow, baseDir?: string): void {
     const allSteps = [...workflow.steps, ...(workflow.finally || [])];
     for (const step of allSteps) {
       if (step.type === 'llm') {
         try {
-          resolveAgentPath(step.agent);
+          resolveAgentPath(step.agent, baseDir);
         } catch (error) {
           throw new Error(`Agent "${step.agent}" referenced in step "${step.id}" not found.`);
         }
@@ -180,11 +181,6 @@ export class WorkflowParser {
       }
     }
 
-    // Initialize in-degree
-    for (const step of workflow.steps) {
-      inDegree.set(step.id, 0);
-    }
-
     // Calculate in-degree
     // In-degree = number of dependencies a step has
     for (const step of workflow.steps) {

package/src/runner/llm-adapter.test.ts

@@ -268,14 +268,6 @@ describe('CopilotAdapter', () => {
     await expect(adapter.chat([])).rejects.toThrow(/GitHub Copilot token not found/);
     spy.mockRestore();
   });
-
-  it('should throw error if token not found (duplicated)', async () => {
-    const spy = spyOn(AuthManager, 'getCopilotToken').mockResolvedValue(undefined);
-
-    const adapter = new CopilotAdapter();
-    await expect(adapter.chat([])).rejects.toThrow(/GitHub Copilot token not found/);
-    spy.mockRestore();
-  });
 });
 
 describe('getAdapter', () => {

package/src/runner/llm-adapter.ts

@@ -141,19 +141,42 @@ export class AnthropicAdapter implements LLMAdapter {
           role: 'assistant',
           content: [
             ...(m.content ? [{ type: 'text' as const, text: m.content }] : []),
-            ...m.tool_calls.map((tc) => ({
-              type: 'tool_use' as const,
-              id: tc.id,
-              name: tc.function.name,
-              input: JSON.parse(tc.function.arguments),
-            })),
+            ...m.tool_calls.map((tc) => {
+              let input = {};
+              try {
+                input =
+                  typeof tc.function.arguments === 'string'
+                    ? JSON.parse(tc.function.arguments)
+                    : tc.function.arguments;
+              } catch (e) {
+                console.error(`Failed to parse tool arguments: ${tc.function.arguments}`);
+              }
+              return {
+                type: 'tool_use' as const,
+                id: tc.id,
+                name: tc.function.name,
+                input,
+              };
+            }),
           ],
         });
       } else {
-        anthropicMessages.push({
-          role: m.role as 'user' | 'assistant',
-          content: m.content || '',
-        });
+        const role = m.role as 'user' | 'assistant';
+        const lastMsg = anthropicMessages[anthropicMessages.length - 1];
+
+        if (
+          lastMsg &&
+          lastMsg.role === role &&
+          typeof lastMsg.content === 'string' &&
+          typeof m.content === 'string'
+        ) {
+          lastMsg.content += `\n\n${m.content}`;
+        } else {
+          anthropicMessages.push({
+            role,
+            content: m.content || '',
+          });
+        }
       }
     }