busy-cli 0.2.0 → 0.3.0

package/src/package/manifest.ts

@@ -347,3 +347,141 @@ export async function fetchPackageFromManifest(
     integrity,
   };
 }
+
+/**
+ * Recursively discover all files in a directory.
+ * Skips hidden directories (e.g. .git, .libraries) and node_modules.
+ */
+export async function discoverFiles(dirPath: string): Promise<string[]> {
+  const results: string[] = [];
+
+  async function walk(dir: string) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith('.') || entry.name === 'node_modules') {
+        continue;
+      }
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+      } else if (entry.isFile()) {
+        results.push(fullPath);
+      }
+    }
+  }
+
+  await walk(dirPath);
+  return results;
+}
+
+/**
+ * Fetch a package from a local folder, copying all files.
+ *
+ * If a package.busy.md exists, its metadata (name, version, description) is used.
+ * Otherwise, metadata is derived from the folder name.
+ */
+export async function fetchPackageFromLocalFolder(
+  workspaceRoot: string,
+  folderPath: string,
+): Promise<FetchPackageResult> {
+  const absolutePath = path.isAbsolute(folderPath)
+    ? folderPath
+    : path.resolve(process.cwd(), folderPath);
+
+  // Verify it's a directory
+  const stat = await fs.stat(absolutePath);
+  if (!stat.isDirectory()) {
+    throw new Error(`Not a directory: ${absolutePath}`);
+  }
+
+  // Try to read manifest for metadata
+  const manifestPath = path.join(absolutePath, 'package.busy.md');
+  let manifest: PackageManifest | null = null;
+  let manifestContent: string | null = null;
+
+  try {
+    manifestContent = await fs.readFile(manifestPath, 'utf-8');
+    manifest = parsePackageManifest(manifestContent);
+  } catch {
+    // No manifest - that's fine
+  }
+
+  const packageName = manifest?.name || path.basename(absolutePath);
+
+  // Discover all files in the folder
+  const discoveredFiles = await discoverFiles(absolutePath);
+
+  // Filter out package.busy.md itself (handled separately)
+  const filesToCopy = discoveredFiles
+    .filter(f => path.basename(f) !== 'package.busy.md')
+    .map(f => ({
+      relativePath: path.relative(absolutePath, f),
+      absolutePath: f,
+    }));
+
+  // Initialize cache
+  const cache = new CacheManager(workspaceRoot);
+  await cache.init();
+
+  // Copy files
+  let combinedContent = '';
+  const documents: PackageDocument[] = [];
+
+  for (const file of filesToCopy) {
+    try {
+      const content = await fs.readFile(file.absolutePath, 'utf-8');
+      combinedContent += content;
+
+      const cachePath = path.join(packageName, file.relativePath);
+      await cache.save(cachePath, content);
+
+      documents.push({
+        name: path.basename(file.relativePath, path.extname(file.relativePath)),
+        relativePath: './' + file.relativePath,
+      });
+    } catch (error) {
+      console.warn(`Warning: Failed to read ${file.absolutePath}: ${error}`);
+    }
+  }
+
+  // Save manifest if it exists
+  if (manifestContent) {
+    await cache.save(path.join(packageName, 'package.busy.md'), manifestContent);
+  }
+
+  // Calculate integrity
+  const integrity = calculateIntegrity(combinedContent);
+
+  // Add to registry
+  const registry = new PackageRegistry(workspaceRoot);
+  try {
+    await registry.load();
+  } catch {
+    await registry.init();
+    await registry.load();
+  }
+
+  const entry: PackageEntry = {
+    id: packageName,
+    description: manifest?.description || '',
+    source: absolutePath,
+    provider: 'local',
+    cached: `.libraries/${packageName}`,
+    version: manifest?.version || 'latest',
+    fetched: new Date().toISOString(),
+    integrity,
+    category: 'Packages',
+  };
+
+  registry.addPackage(entry);
+  await registry.save();
+
+  return {
+    name: packageName,
+    version: manifest?.version || 'latest',
+    description: manifest?.description || '',
+    documents,
+    cached: `.libraries/${packageName}`,
+    integrity,
+  };
+}

package/src/parser.ts

@@ -217,14 +217,16 @@ export function resolveImports(
     // Resolve the import path
     const importPath = resolve(dirname(basePath), imp.path);
 
-    // Check for circular imports
+    // Check for circular imports — warn and skip instead of crashing
     if (visited.has(importPath)) {
-      throw new Error(`Circular import detected: ${importPath}`);
+      console.warn(`⚠ Circular import skipped: ${imp.path} (from ${basePath})`);
+      continue;
     }
 
-    // Check if file exists
+    // Check if file exists — warn and skip instead of crashing
     if (!existsSync(importPath)) {
-      throw new Error(`Import not found: ${imp.path} (resolved to ${importPath})`);
+      console.warn(`⚠ Import not found: ${imp.path} (resolved to ${importPath})`);
+      continue;
     }
 
     // Mark as visited
@@ -248,7 +250,7 @@ export function resolveImports(
         );
 
         if (!hasOperation && !hasDefinition) {
-          throw new Error(`Anchor '${imp.anchor}' not found in ${imp.path}`);
+          console.warn(`⚠ Anchor '${imp.anchor}' not found in ${imp.path}`);
         }
       }
 
@@ -258,10 +260,12 @@ export function resolveImports(
       // Recursively resolve imports in the imported document
       const nestedResolved = resolveImports(importedDoc, importPath, visited);
       Object.assign(resolved, nestedResolved);
-    } finally {
-      // Remove from visited after processing (allow same doc in different branches)
-      visited.delete(importPath);
+    } catch (e) {
+      // Don't crash on nested resolution failures
+      console.warn(`⚠ Failed to resolve nested imports in ${imp.path}: ${e}`);
     }
+    // NOTE: we intentionally keep importPath in `visited` — once resolved,
+    // don't re-resolve in other branches (prevents exponential recursion)
   }
 
   return resolved;

package/src/types/schema.ts

@@ -160,7 +160,7 @@ type Section = {
 };
 
 type ConceptBase = {
-  kind: 'concept' | 'document' | 'operation' | 'checklist' | 'tool' | 'playbook' | 'localdef' | 'importdef' | 'setup';
+  kind: 'concept' | 'document' | 'operation' | 'checklist' | 'tool' | 'playbook' | 'view' | 'config' | 'localdef' | 'importdef' | 'setup';
   id: string;
   docId: string;
   slug: string;
@@ -194,7 +194,7 @@ export type { Section };
 
 // ConceptBase schema - need to keep as regular object schema to allow .extend()
 const ConceptBaseSchemaObject = z.object({
-  kind: z.enum(['concept', 'document', 'operation', 'checklist', 'tool', 'playbook', 'localdef', 'importdef', 'setup']),
+  kind: z.enum(['concept', 'document', 'operation', 'checklist', 'tool', 'playbook', 'view', 'config', 'localdef', 'importdef', 'setup']),
   id: ConceptIdSchema,
   docId: DocIdSchema,
   slug: z.string(),
@@ -261,6 +261,18 @@ export const PlaybookSchema = LegacyBusyDocumentSchema.extend({
     sequence: z.array(ConceptIdSchema), // Ordered array of operation references
   })
 
+// View schema - extends LegacyBusyDocument with display section
+// Views follow MVC: imports=Model, localDefs=ViewModel, template=View, operations=Controller
+export const ViewSchema = LegacyBusyDocumentSchema.extend({
+    kind: z.literal('view'),
+    display: z.string().optional(), // Markdown template (optional — LORE can generate)
+  })
+
+// Config schema - extends LegacyBusyDocument, semantically a singleton Model
+export const ConfigSchema = LegacyBusyDocumentSchema.extend({
+    kind: z.literal('config'),
+  })
+
 // Edge schema
 export const EdgeRoleSchema = z.enum(['ref', 'calls', 'extends', 'imports']);
 export const EdgeSchema = z.object({
@@ -287,7 +299,7 @@ export const RepoSchema = z.object({
   byId: z.record(z.union([SectionSchema, LocalDefSchema, LegacyOperationSchema, ConceptBaseSchema])),
   byFile: z.record( // Renamed from byDoc for clarity
     z.object({
-      concept: z.union([LegacyBusyDocumentSchema, PlaybookSchema]), // The concept defined in this file
+      concept: z.union([LegacyBusyDocumentSchema, PlaybookSchema, ViewSchema, ConfigSchema]), // The concept defined in this file
       bySlug: z.record(SectionSchema),
     })
   ),
@@ -319,6 +331,8 @@ export type Slug = z.infer<typeof SlugSchema>;
 // Section and ConceptBase types defined above to avoid circular references
 export type LegacyBusyDocument = z.infer<typeof LegacyBusyDocumentSchema>;
 export type Playbook = z.infer<typeof PlaybookSchema>;
+export type View = z.infer<typeof ViewSchema>;
+export type Config = z.infer<typeof ConfigSchema>;
 export type LocalDef = z.infer<typeof LocalDefSchema>;
 export type LegacyOperation = z.infer<typeof LegacyOperationSchema>;
 export type ImportDef = z.infer<typeof ImportDefSchema>;