feat: add feature Ideas document and link from roadmap

refactor: update interpolation syntax in documentation examples
chore: add DotSettings for code inspection configuration

Author: wendellmva

docs/Feature-Ideas.md

@@ -0,0 +1,181 @@
+# TinyTools Feature Ideas
+
+This document collects small, focused feature ideas that fit TinyTools' core philosophy:
+
+> Keep templates tiny, deterministic, dependency-light, and useful for data composition.
+
+These ideas are not commitments. They are candidates to evaluate against the roadmap, implementation cost, and the project's goal of staying intentionally small.
+
+---
+
+## Recommended First Feature
+
+### Template Diagnostics and Strict Mode
+
+The strongest next feature candidate is a diagnostics layer with optional strict rendering.
+
+Today, TinyTools is already useful for rendering deterministic text. The next quality-of-life improvement would be helping users find template mistakes before output is generated or shipped.
+
+Possible API:
+
+```csharp
+var diagnostics = engine.Analyze(template);
+
+foreach (var diagnostic in diagnostics)
+{
+    Console.WriteLine($"{diagnostic.Line}:{diagnostic.Column} {diagnostic.Message}");
+}
+```
+
+Strict rendering could build on the same analysis model:
+
+```csharp
+var engine = new TinyTemplateEngine(new TinyTemplateOptions
+{
+    StrictVariables = true,
+    StrictHelpers = true
+});
+```
+
+Suggested diagnostics:
+
+- Missing or unresolved variables
+- Unknown pipe helpers
+- Unmatched `@if`, `@foreach`, `@else`, or closing braces
+- Invalid null-coalescing or ternary expressions
+- Line and column information for template errors
+- Suggestions for common mistakes, such as misspelled helper names
+
+Why it fits:
+
+- Improves trust without making templates more powerful or complex
+- Supports existing validation work
+- Helps CLI, editor tooling, and future source-generator scenarios
+- Keeps error handling deterministic and easy to test
+
+---
+
+## Other Strong Candidates
+
+### Render From JSON
+
+TinyTools is often used for data composition, and JSON is a natural input format for templates. A first-class JSON render path would make examples, tests, CLIs, and automation easier.
+
+Possible API:
+
+```csharp
+var output = engine.RenderJson(template, json);
+```
+
+Possible overloads:
+
+```csharp
+var output = engine.RenderJson(template, jsonString);
+var output = engine.RenderJson(template, jsonDocument);
+var output = engine.RenderJsonFile(template, "data.json");
+```
+
+Why it fits:
+
+- Aligns with generating JSON, YAML, Markdown, config files, prompts, and emails
+- Makes CLI rendering easier to implement later
+- Gives users a simple bridge from external data into `ToolContext`
+
+### Escaping Helpers
+
+TinyTools is format-agnostic, so it should help users safely project values into common text formats without becoming an HTML view engine.
+
+Possible helpers:
+
+```text
+${Context.Name | json}
+${Context.Description | yaml}
+${Context.Value | csv}
+${Context.Text | markdown}
+```
+
+Why it fits:
+
+- Supports non-HTML output formats
+- Keeps escaping explicit in the template
+- Reduces accidental invalid JSON, CSV, YAML, or Markdown output
+
+### Template Includes
+
+Includes would allow reusable fragments while keeping templates simple.
+
+Possible syntax:
+
+```text
+@include("partials/header.tmpl")
+
+Content here
+
+@include("partials/footer.tmpl")
+```
+
+Recommended design:
+
+```csharp
+public interface ITemplateLoader
+{
+    string Load(string path);
+}
+```
+
+Why it fits:
+
+- Enables reusable headers, footers, prompts, and generated-file fragments
+- Keeps file-system behavior outside the engine
+- Allows in-memory, embedded-resource, and file-based loaders
+
+### Tiny CLI
+
+A small command-line tool would make TinyTools useful outside application code.
+
+Possible commands:
+
+```bash
+tinytools render --template email.tmpl --data data.json --out email.txt
+tinytools validate --template email.tmpl --data data.json
+tinytools watch --template "*.tmpl" --data data.json --out output
+```
+
+Why it fits:
+
+- Makes the library easier to try
+- Supports automation and code-generation workflows
+- Provides a practical surface for diagnostics and JSON rendering
+
+---
+
+## Lower Priority Ideas
+
+### File-Based Template Registry
+
+Allow a registry to discover `.tmpl` files from a folder and render them by name.
+
+This is useful, but it should probably come after includes and diagnostics so file templates have a clearer error model.
+
+### Editor Tooling
+
+Syntax highlighting, diagnostics, and preview tooling would be valuable. This should likely build on the diagnostics API rather than being implemented first.
+
+### Source Generator Templates
+
+Build-time template generation could be powerful, but it has a larger maintenance surface. It should probably wait until the parser, diagnostics, and strict behavior are stable.
+
+---
+
+## Guardrails
+
+These feature ideas should preserve the current TinyTools boundaries:
+
+- No HTML-first view rendering
+- No runtime code execution
+- No JavaScript engine
+- No heavy dependencies
+- No broad template DSL expansion
+- No hidden global file-system behavior
+
+TinyTools should stay boring in the best way: predictable, inspectable, and easy to reason about.

roadmap.md

@@ -176,6 +176,8 @@ dotnet tinytools watch --template *.tmpl
 
 ## Future Considerations (2027+)
 
+Additional candidate features are tracked in [docs/Feature-Ideas.md](docs/Feature-Ideas.md). That document collects smaller ideas that may feed future roadmap updates.
+
 ### Under Consideration
 
 #### ?? Localization/Internationalization

site/src/pages/api-reference.tsx

@@ -27,10 +27,10 @@ export function ApiReferencePage() {
               language="csharp"
             />
             <p className="text-sm text-muted-foreground mt-2 mb-2">
-              Replaces {"{PropertyName}"} tags with values from an anonymous object or class.
+              Replaces {"${PropertyName}"} tags with values from an anonymous object or class.
             </p>
             <CodeBlock
-              code={`var template = "Hello {FirstName} {LastName}!";
+              code={`var template = "Hello \${FirstName} \${LastName}!";
 var model = new { FirstName = "John", LastName = "Smith" };
 var result = template.Interpolate(model);
 // Output: "Hello John Smith!"`}
@@ -44,10 +44,10 @@ var result = template.Interpolate(model);
               language="csharp"
             />
             <p className="text-sm text-muted-foreground mt-2 mb-2">
-              Replaces {"{Key}"} tags with values from a dictionary.
+              Replaces {"${Key}"} tags with values from a dictionary.
             </p>
             <CodeBlock
-              code={`var template = "Welcome to {City}, {Country}!";
+              code={`var template = "Welcome to \${City}, \${Country}!";
 var data = new Dictionary<string, string>
 {
     { "City", "Amsterdam" },

site/src/pages/getting-started.tsx

@@ -37,7 +37,7 @@ return (
             code={`using LowlandTech.TinyTools;
 
 // Simple property interpolation
-var template = "Hello {FirstName} {LastName}!";
+var template = "Hello \${FirstName} \${LastName}!";
 var model = new { FirstName = "John", LastName = "Smith" };
 
 var result = template.Interpolate(model);
@@ -57,12 +57,12 @@ var result = template.Interpolate(model);
         <CardContent className="space-y-4">
           <CodeBlock
             code={`var template = """
-    Hi {CustomerName},
+              Hi \${CustomerName},
 
-    Thank you for your order #{OrderNumber}.
+              Thank you for your order #\${OrderNumber}.
     Your total is ${"${TotalAmount}"}.
 
-    We'll send a confirmation to {Email}.
+              We'll send a confirmation to \${Email}.
     """;
 
 var model = new 

site/src/pages/home.tsx

@@ -32,7 +32,7 @@ const features = [
 ];
 
 const helloWorldExample = `// Simple string interpolation
-var template = "Hello {FirstName} {LastName}!";
+var template = "Hello \${FirstName} \${LastName}!";
 var model = new { FirstName = "John", LastName = "Smith" };
 
 var result = template.Interpolate(model);`;
@@ -41,12 +41,12 @@ const helloWorldOutput = `Hello John Smith!`;
 
 const emailExample = `// Email template example
 var template = """
-    Hi {CustomerName},
+  Hi \${CustomerName},
     
-    Thank you for your order #{OrderNumber}.
-    Your total is {Total}.
+  Thank you for your order #\${OrderNumber}.
+  Your total is \${Total}.
     
-    We'll send confirmation to {Email}.
+  We'll send confirmation to \${Email}.
     """;
 
 var model = new 

site/src/pages/variable-resolver.tsx

@@ -22,15 +22,15 @@ return (
         <CardContent>
           <Tabs defaultValue="simple">
             <TabsList className="grid w-full grid-cols-2">
-              <TabsTrigger value="simple">Simple {"{PropertyName}"}</TabsTrigger>
+              <TabsTrigger value="simple">Simple ${"${PropertyName}"}</TabsTrigger>
               <TabsTrigger value="engine">Engine ${"${Context.xxx}"}</TabsTrigger>
             </TabsList>
             <TabsContent value="simple" className="space-y-4">
               <p className="text-sm text-muted-foreground">
-                Use the <code>Interpolate</code> extension for quick, tag-based replacements.
+                Use the <code>Interpolate</code> extension for quick, `${"${var}"}`-style replacements.
               </p>
               <CodeBlock
-                code={`var template = "Hello {FirstName} {LastName}";
+                code={`var template = "Hello \${FirstName} \${LastName}";
 var model = new { FirstName = "John", LastName = "Smith" };
 
 var result = template.Interpolate(model);
@@ -41,7 +41,7 @@ var result = template.Interpolate(model);
                 Dictionary models are also supported:
               </p>
               <CodeBlock
-                code={`var template = "Hello {Name}";
+                code={`var template = "Hello \${Name}";
 var model = new Dictionary<string, string> { ["Name"] = "Jane" };
 var result = template.Interpolate(model);
 // Output: Hello Jane`}

src/lib/LowlandTech.TinyTools.csproj.DotSettings

@@ -0,0 +1,6 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=core/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=helpers/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=infrastructure/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=registry/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=templates/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>