@slycode/slycode 0.2.5 → 0.2.7

package/dist/web/package.json

@@ -11,6 +11,7 @@
     "lint": "eslint"
   },
   "dependencies": {
+    "@aws-sdk/client-transcribe-streaming": "^3.1012.0",
     "@tailwindcss/typography": "^0.5.19",
     "@xterm/addon-fit": "^0.11.0",
     "@xterm/addon-web-links": "^0.12.0",

package/dist/web/src/app/api/transcribe/route.ts

@@ -4,8 +4,16 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import { execFile } from 'child_process';
 import { getSlycodeRoot } from '@/lib/paths';
+import {
+  TranscribeStreamingClient,
+  StartStreamTranscriptionCommand,
+  type AudioStream,
+  type LanguageCode,
+  type MediaEncoding,
+} from '@aws-sdk/client-transcribe-streaming';
 
 let openaiClient: OpenAI | null = null;
+let transcribeClient: TranscribeStreamingClient | null = null;
 let envLoaded = false;
 let envCache: Record<string, string> = {};
 
@@ -41,6 +49,13 @@ async function getClient(): Promise<OpenAI> {
   return openaiClient;
 }
 
+function getTranscribeClient(region?: string): TranscribeStreamingClient {
+  if (!transcribeClient) {
+    transcribeClient = new TranscribeStreamingClient(region ? { region } : {});
+  }
+  return transcribeClient;
+}
+
 function execAsync(cmd: string, args: string[], options: Record<string, unknown>): Promise<string> {
   return new Promise((resolve, reject) => {
     execFile(cmd, args, { ...options, windowsHide: true }, (error, stdout, stderr) => {
@@ -76,6 +91,78 @@ async function transcribeLocal(audioBuffer: Buffer, ext: string, cliPath: string
   }
 }
 
+async function transcribeAwsStreaming(audioBuffer: Buffer, ext: string, region: string, language: string): Promise<string> {
+  const client = getTranscribeClient(region || undefined);
+
+  const isOgg = ext === 'ogg' || ext === 'oga';
+
+  let streamBuffer: Buffer;
+  let mediaEncoding: MediaEncoding;
+  let sampleRate: number;
+  let pcmPath: string | null = null;
+
+  if (isOgg) {
+    // OGG/Opus can be sent directly
+    streamBuffer = audioBuffer;
+    mediaEncoding = 'ogg-opus';
+    sampleRate = 48000;
+  } else {
+    // Convert WebM/MP4 to PCM via ffmpeg
+    const tmpDir = process.env.TMPDIR || '/tmp';
+    const tmpFile = path.join(tmpDir, `transcribe_${Date.now()}.${ext}`);
+    pcmPath = tmpFile.replace(/\.[^.]+$/, '.pcm');
+
+    try {
+      await fs.writeFile(tmpFile, audioBuffer);
+      await execAsync('ffmpeg', [
+        '-i', tmpFile, '-ar', '16000', '-ac', '1', '-f', 's16le', '-y', pcmPath,
+      ], { timeout: 30_000 });
+      streamBuffer = await fs.readFile(pcmPath);
+      await fs.unlink(tmpFile).catch(() => {});
+    } catch (err) {
+      await fs.unlink(tmpFile).catch(() => {});
+      throw new Error(`ffmpeg conversion to PCM failed: ${(err as Error).message}`);
+    }
+    mediaEncoding = 'pcm';
+    sampleRate = 16000;
+  }
+
+  const chunkSize = 4096;
+  async function* audioStream(): AsyncGenerator<AudioStream> {
+    for (let offset = 0; offset < streamBuffer.length; offset += chunkSize) {
+      yield { AudioEvent: { AudioChunk: streamBuffer.subarray(offset, offset + chunkSize) } };
+    }
+  }
+
+  try {
+    const response = await client.send(new StartStreamTranscriptionCommand({
+      LanguageCode: language as LanguageCode,
+      MediaEncoding: mediaEncoding,
+      MediaSampleRateHertz: sampleRate,
+      AudioStream: audioStream(),
+    }));
+
+    const parts: string[] = [];
+    if (response.TranscriptResultStream) {
+      for await (const event of response.TranscriptResultStream) {
+        if (event.TranscriptEvent?.Transcript?.Results) {
+          for (const result of event.TranscriptEvent.Transcript.Results) {
+            if (!result.IsPartial && result.Alternatives?.[0]?.Transcript) {
+              parts.push(result.Alternatives[0].Transcript);
+            }
+          }
+        }
+      }
+    }
+
+    return parts.join(' ').trim();
+  } finally {
+    if (pcmPath) {
+      await fs.unlink(pcmPath).catch(() => {});
+    }
+  }
+}
+
 export async function POST(request: Request) {
   try {
     const formData = await request.formData();
@@ -102,7 +189,15 @@ export async function POST(request: Request) {
       return NextResponse.json({ text });
     }
 
-    // OpenAI API path
+    if (backend === 'aws-transcribe') {
+      const region = process.env.AWS_TRANSCRIBE_REGION || env.AWS_TRANSCRIBE_REGION || '';
+      const language = process.env.AWS_TRANSCRIBE_LANGUAGE || env.AWS_TRANSCRIBE_LANGUAGE || 'en-AU';
+
+      const text = await transcribeAwsStreaming(buffer, ext, region, language);
+      return NextResponse.json({ text });
+    }
+
+    // OpenAI API path (default)
     let client: OpenAI;
     try {
       client = await getClient();

package/dist/web/src/lib/store-scanner.ts

@@ -17,36 +17,6 @@ function getStorePath(): string {
   return path.join(getSlycodeRoot(), 'store');
 }
 
-/** Load manifest lists. Returns null if manifest not found. */
-function loadManifest(): { skills: string[]; actions: string[]; agents: string[]; mcp: string[] } | null {
-  // Try multiple locations: dev repo, then package dist
-  const candidates = [
-    path.join(getSlycodeRoot(), 'build', 'store-manifest.js'),
-    path.join(getSlycodeRoot(), 'node_modules', '@slycode', 'slycode', 'build', 'store-manifest.js'),
-  ];
-  for (const p of candidates) {
-    try {
-      if (fs.existsSync(p)) {
-        // Use dynamic import workaround — read and parse manually to avoid require()
-        const content = fs.readFileSync(p, 'utf-8');
-        const mod: Record<string, unknown> = {};
-        const fn = new Function('module', 'exports', content);
-        fn(mod, mod);
-        const result = (mod as { exports?: { skills?: string[]; actions?: string[]; agents?: string[]; mcp?: string[] } }).exports;
-        if (result?.skills) return {
-          skills: result.skills,
-          actions: result.actions || [],
-          agents: result.agents || [],
-          mcp: result.mcp || [],
-        };
-      }
-    } catch {
-      // Try next candidate
-    }
-  }
-  return null;
-}
-
 // ============================================================================
 // Store Directory Scanning
 // ============================================================================
@@ -154,56 +124,25 @@ function scanStoreMcp(storePath: string): StoreAssetInfo[] {
 // ============================================================================
 
 /**
- * Full store scan — returns only manifest-approved assets.
+ * Full store scan — returns all assets in the store.
+ * The manifest is only used by the build pipeline (build-package.ts) to control
+ * what ships in the npm package. The store UI shows everything.
  */
 export function scanStore(): StoreData {
   const storePath = getStorePath();
-  const manifest = loadManifest();
-
-  let skills = scanStoreAssetDir(storePath, 'skill');
-  let agents = scanStoreAssetDir(storePath, 'agent');
-  let mcp = scanStoreMcp(storePath);
-
-  if (manifest) {
-    if (manifest.skills) {
-      const allowed = new Set(manifest.skills);
-      skills = skills.filter(s => allowed.has(s.name));
-    }
-    if (manifest.agents) {
-      const allowed = new Set(manifest.agents);
-      agents = agents.filter(a => allowed.has(a.name));
-    }
-    if (manifest.mcp) {
-      const allowed = new Set(manifest.mcp);
-      mcp = mcp.filter(m => allowed.has(m.name));
-    }
-  }
-
+  const skills = scanStoreAssetDir(storePath, 'skill');
+  const agents = scanStoreAssetDir(storePath, 'agent');
+  const mcp = scanStoreMcp(storePath);
   return { skills, agents, mcp };
 }
 
 /**
  * Get flat list of all store assets (skills + agents).
  * Used as the master source for project matrix comparison.
- * Skills are filtered by manifest.
  */
 export function getStoreAssets(): StoreAssetInfo[] {
   const storePath = getStorePath();
-  const manifest = loadManifest();
-
-  let skills = scanStoreAssetDir(storePath, 'skill');
-  let agents = scanStoreAssetDir(storePath, 'agent');
-
-  if (manifest) {
-    if (manifest.skills) {
-      const allowed = new Set(manifest.skills);
-      skills = skills.filter(s => allowed.has(s.name));
-    }
-    if (manifest.agents) {
-      const allowed = new Set(manifest.agents);
-      agents = agents.filter(a => allowed.has(a.name));
-    }
-  }
-
+  const skills = scanStoreAssetDir(storePath, 'skill');
+  const agents = scanStoreAssetDir(storePath, 'agent');
   return [...skills, ...agents];
 }