Fix devfile init flow to match odo behavior

**Problem:**
- materializeStarterProjects() called BEFORE parent resolution
- nodejs-basic has no starter projects (they're in parent nodejs:2.2.0)
- Result: starter materialization failed
- Also: downloadResources mode tried to download URIs during init (404 errors)

**Root cause:**
ODO doesn't download URIs during init - they're inlined later during dev/deploy

**Solution:**
1. Resolve parents FIRST to get starter projects from parent chain
2. THEN materialize starter (git clone)
3. Remove downloadResources mode entirely (URIs stay as-is in devfile)
4. Remove .git directory after cloning (matches odo, makes component compact)

**Flow changes:**
BEFORE: fetch → materialize starter (FAIL) → resolve + download URIs (404)
AFTER:  fetch → resolve (merge parents) → materialize starter → URIs unchanged

URIs will be inlined later during dev/deploy using inlineResources mode.

**Files changed:**
- src/devfile/init.ts: Add parent resolution before starter, remove downloadResources, add .git removal
- src/devfile/devfileResolver.ts: Remove downloadResources option, keep only inlineResources
- test/unit/devfile/devfileResolver.test.ts: Remove downloadResources tests
- test/integration/devfileResolver.test.ts: Remove downloadResources test

Signed-off-by: Victor Rubezhny <vrubezhny@redhat.com>
Assisted-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: vrubezhny

.claude/plans/fix-registry-resource-download.md

@@ -0,0 +1,262 @@
+# Fix: Registry Resource Download
+
+## Problem
+
+Current implementation in `src/devfile-registry/devfileRegistryWrapper.ts` hard-codes GitHub URLs when downloading stack resources (kubernetes manifests, dockerfiles, etc.):
+
+```typescript
+// Line 370-371 in downloadFromRegistryRepo()
+const url = `https://raw.githubusercontent.com/devfile/registry/main/stacks/${stackName}/${version}/${uriPath}`;
+return DevfileRegistry._get(url);
+```
+
+**This breaks for:**
+- Non-GitHub registries (https://registry.devfile.io, https://registry.stage.devfile.io)
+- Custom/private registries
+- GitLab, Bitbucket, or other hosting platforms
+
+**Test failure:** HTTP 429 (Too Many Requests) from GitHub's rate limiting.
+
+## Root Cause
+
+The code assumes ALL devfile registries use GitHub, which is incorrect. Each registry can be hosted anywhere.
+
+## How ODO Does It (Correct Approach)
+
+ODO delegates to the **devfile library (Go)** which implements proper URI resolution:
+
+### Key Code from `devfile/library/v2/pkg/devfile/parser/parse.go`
+
+When `ConvertKubernetesContentInUri = true`, the library calls `getKubernetesDefinitionFromUri()`:
+
+```go
+// Line 854-890
+func getKubernetesDefinitionFromUri(uri string, d devfileCtx.DevfileCtx, devfileUtilsClient parserUtil.DevfileUtils) ([]byte, error) {
+    absoluteURL := strings.HasPrefix(uri, "http://") || strings.HasPrefix(uri, "https://")
+    
+    // Case 1: Relative path on disk
+    if !absoluteURL && d.GetAbsPath() != "" {
+        newUri = path.Join(path.Dir(d.GetAbsPath()), uri)
+        data = fs.ReadFile(newUri)
+    }
+    
+    // Case 2: Relative path to a URL (KEY INSIGHT!)
+    else if d.GetURL() != "" {
+        u = parse(d.GetURL())  // e.g., "https://registry.devfile.io/devfiles/go/2.6.0"
+        u.Path = path.Join(path.Dir(u.Path), uri)  // "kubernetes/deploy.yaml"
+        newUri = u.String()  // "https://registry.devfile.io/devfiles/go/2.6.0/kubernetes/deploy.yaml"
+        data = DownloadInMemory(newUri)
+    }
+    
+    // Case 3: Absolute HTTP URL
+    else if absoluteURL {
+        newUri = uri
+        data = DownloadInMemory(newUri)
+    }
+    
+    return data
+}
+```
+
+### The Key Insight
+
+**Relative URIs are resolved against the devfile's source URL!**
+
+If devfile came from:
+```
+https://registry.devfile.io/devfiles/go/2.6.0
+```
+
+And has:
+```yaml
+components:
+  - name: deploy
+    kubernetes:
+      uri: kubernetes/deploy.yaml
+```
+
+It resolves to:
+```
+https://registry.devfile.io/devfiles/go/2.6.0/kubernetes/deploy.yaml
+```
+
+**This IS the registry REST API pattern!**
+
+## Solution
+
+### Phase 1: Store Devfile Source URL
+
+When we fetch a devfile from a registry, store its source URL:
+
+```typescript
+// In DevfileResolver or similar
+interface ResolvedDevfile {
+    devfile: Data;
+    sourceUrl?: string;  // NEW: Track where this came from
+}
+```
+
+### Phase 2: Implement Proper URI Resolution
+
+Create a utility similar to the Go library:
+
+```typescript
+export class DevfileUriResolver {
+    /**
+     * Resolves a URI from a devfile component (kubernetes.uri, dockerfile.uri, etc.)
+     * following the same logic as devfile/library Go implementation
+     */
+    public static async resolveUri(
+        uri: string,
+        devfileSourceUrl?: string,
+        devfileAbsPath?: string
+    ): Promise<string> {
+        const absoluteURL = uri.startsWith('http://') || uri.startsWith('https://');
+        
+        // Case 1: Relative path on disk
+        if (!absoluteURL && devfileAbsPath) {
+            return path.join(path.dirname(devfileAbsPath), uri);
+        }
+        
+        // Case 2: Relative path to a URL (resolve against registry endpoint)
+        if (!absoluteURL && devfileSourceUrl) {
+            const u = new URL(devfileSourceUrl);
+            u.pathname = path.join(path.dirname(u.pathname), uri);
+            return u.toString();
+        }
+        
+        // Case 3: Absolute URL
+        if (absoluteURL) {
+            return uri;
+        }
+        
+        throw new Error(`Cannot resolve URI '${uri}': no devfile source context available`);
+    }
+    
+    /**
+     * Downloads content from a resolved URI
+     */
+    public static async downloadContent(resolvedUri: string): Promise<string> {
+        if (resolvedUri.startsWith('http://') || resolvedUri.startsWith('https://')) {
+            // Use got library (via DownloadUtil) or simple http.get
+            // Add retry logic with exponential backoff for 429 responses
+            return this.downloadWithRetry(resolvedUri);
+        }
+        
+        // Local file
+        return fs.readFile(resolvedUri, 'utf-8');
+    }
+    
+    private static async downloadWithRetry(url: string, retries = 3): Promise<string> {
+        for (let attempt = 0; attempt < retries; attempt++) {
+            try {
+                // Use got library or http.get
+                return await this.httpGet(url);
+            } catch (err) {
+                if (err.statusCode === 429 && attempt < retries - 1) {
+                    // Exponential backoff: 1s, 2s, 4s
+                    await sleep(Math.pow(2, attempt) * 1000);
+                    continue;
+                }
+                throw err;
+            }
+        }
+    }
+}
+```
+
+### Phase 3: Update downloadStackExtraFiles()
+
+Replace the hard-coded GitHub logic:
+
+```typescript
+// In devfileRegistryWrapper.ts
+private async downloadFromRegistryRepo(
+    registryUrl: string,
+    stackName: string,
+    version: string,
+    uriPath: string
+): Promise<string> {
+    // Build the proper registry endpoint URL
+    const devfileSourceUrl = `${registryUrl}/devfiles/${stackName}/${version}`;
+    
+    // Resolve URI against registry endpoint
+    const resolvedUrl = await DevfileUriResolver.resolveUri(
+        uriPath,
+        devfileSourceUrl
+    );
+    
+    // Download with retry logic
+    return DevfileUriResolver.downloadContent(resolvedUrl);
+}
+```
+
+### Phase 4: Handle Edge Cases
+
+1. **Registry doesn't serve files (404):** 
+   - Could fall back to GitHub for devfile.io registries (but log a warning)
+   - Or fail with clear error message
+
+2. **Rate limiting (429):**
+   - Retry with exponential backoff
+   - Add caching (already implemented in `getStackFile()`)
+
+3. **Authentication:**
+   - Support auth tokens like the Go library does
+
+## Testing Strategy
+
+### Unit Tests
+
+1. URI resolution:
+   - Absolute HTTP URLs
+   - Relative paths with devfile source URL
+   - Relative paths with local file
+   - Error cases (no context)
+
+2. Download with retry:
+   - Successful download
+   - 429 response → retry → success
+   - Non-retriable error → fail immediately
+
+### Integration Tests
+
+1. Download from registry.devfile.io
+2. Download from registry.stage.devfile.io
+3. Handle 404 gracefully
+4. Handle 429 with retry
+
+## Files to Modify
+
+1. **src/devfile/devfileUriResolver.ts** (NEW)
+   - URI resolution logic
+   - Download with retry
+
+2. **src/devfile-registry/devfileRegistryWrapper.ts**
+   - Replace `downloadFromRegistryRepo()` implementation
+   - Store devfile source URL when fetching from registry
+
+3. **src/devfile/devfileResolver.ts**
+   - Track source URL in resolved devfiles
+   - Optionally: implement `ConvertKubernetesContentInUri`-like functionality
+
+4. **test/unit/devfile/devfileUriResolver.test.ts** (NEW)
+   - URI resolution tests
+   - Download retry tests
+
+## References
+
+- [Devfile Library Go Implementation](https://github.com/devfile/library)
+- [Devfile API Issue #46](https://github.com/devfile/api/issues/46#issuecomment-1093301551)
+- [Registry REST API](https://github.com/devfile/registry-support/blob/main/index/server/registry-REST-API.adoc)
+- ODO source: `/home/jeremy/projects/redhat-developer/odo/vendor/github.com/devfile/library/v2/pkg/devfile/parser/parse.go:847-890`
+
+## Timeline
+
+- URI resolver implementation: 2-3 hours
+- Update registry wrapper: 1 hour
+- Unit tests: 2 hours
+- Integration tests: 1 hour
+- Manual testing: 1 hour
+
+**Total: ~7-8 hours**

.gitignore

@@ -11,4 +11,4 @@ dist/
 public/
 test-resources/
 .DS_Store
-
+.claude/